{ "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-08-16T06:32:44.757710Z", "iopub.status.busy": "2024-08-16T06:32:44.757485Z", "iopub.status.idle": "2024-08-16T06:32:44.761332Z", "shell.execute_reply": "2024-08-16T06:32:44.760791Z" }, "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-08-16T06:32:44.764988Z", "iopub.status.busy": "2024-08-16T06:32:44.764768Z", "iopub.status.idle": "2024-08-16T06:32:47.117540Z", "shell.execute_reply": "2024-08-16T06:32:47.116811Z" }, "id": "WZKbyU2-AiY-" }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "2024-08-16 06:32:45.015549: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", "2024-08-16 06:32:45.036284: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", "2024-08-16 06:32:45.042482: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n" ] } ], "source": [ "import tensorflow as tf" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "execution": { "iopub.execute_input": "2024-08-16T06:32:47.121498Z", "iopub.status.busy": "2024-08-16T06:32:47.121143Z", "iopub.status.idle": "2024-08-16T06:32:47.127684Z", "shell.execute_reply": "2024-08-16T06:32:47.127091Z" }, "id": "wx-zNbLqB4K8" }, "outputs": [ { "data": { "text/plain": [ "'2.17.0'" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tf.__version__" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "execution": { "iopub.execute_input": "2024-08-16T06:32:47.130863Z", "iopub.status.busy": "2024-08-16T06:32:47.130467Z", "iopub.status.idle": "2024-08-16T06:32:52.456371Z", "shell.execute_reply": "2024-08-16T06:32:52.455227Z" }, "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.35.0)\r\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Requirement already satisfied: numpy<2.0.0 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.4.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-l15x1i75\r\n", " Running command git clone --filter=blob:none --quiet https://github.com/tensorflow/docs /tmpfs/tmp/pip-req-build-l15x1i75\r\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " Resolved https://github.com/tensorflow/docs to commit 7d4187e1624afa1caf0639de9ca5b7ccd5ad19e3\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.7.15.51478)\r\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " 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.7.15.51478) (2.1.0)\r\n", "Requirement already satisfied: jinja2 in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from tensorflow-docs==2024.7.15.51478) (3.1.4)\r\n", "Requirement already satisfied: nbformat in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from tensorflow-docs==2024.7.15.51478) (5.10.4)\r\n", "Requirement already satisfied: protobuf>=3.12 in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from tensorflow-docs==2024.7.15.51478) (3.20.3)\r\n", "Requirement already satisfied: pyyaml in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from tensorflow-docs==2024.7.15.51478) (6.0.2)\r\n", "Requirement already satisfied: MarkupSafe>=2.0 in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from jinja2->tensorflow-docs==2024.7.15.51478) (2.1.5)\r\n", "Requirement already satisfied: fastjsonschema>=2.15 in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from nbformat->tensorflow-docs==2024.7.15.51478) (2.20.0)\r\n", "Requirement already satisfied: jsonschema>=2.6 in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from nbformat->tensorflow-docs==2024.7.15.51478) (4.23.0)\r\n", "Requirement already satisfied: jupyter-core!=5.0.*,>=4.12 in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from nbformat->tensorflow-docs==2024.7.15.51478) (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.7.15.51478) (5.14.3)\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.7.15.51478) (24.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.7.15.51478) (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.7.15.51478) (0.35.1)\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.7.15.51478) (0.20.0)\r\n", "Requirement already satisfied: platformdirs>=2.5 in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from jupyter-core!=5.0.*,>=4.12->nbformat->tensorflow-docs==2024.7.15.51478) (4.2.2)\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.7.15.51478-py3-none-any.whl size=182589 sha256=d9d3363c1de21c937b1f390e7c39e1ef39051f12283aa919ae786a674a02ea8d\r\n", " Stored in directory: /tmpfs/tmp/pip-ephem-wheel-cache-hveslr4f/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.7.15.51478\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-08-16T06:32:52.461040Z", "iopub.status.busy": "2024-08-16T06:32:52.460745Z", "iopub.status.idle": "2024-08-16T06:32:52.759966Z", "shell.execute_reply": "2024-08-16T06:32:52.759299Z" }, "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-08-16T06:32:52.763882Z", "iopub.status.busy": "2024-08-16T06:32:52.763618Z", "iopub.status.idle": "2024-08-16T06:32:53.032357Z", "shell.execute_reply": "2024-08-16T06:32:53.031648Z" }, "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-08-16T06:32:53.036481Z", "iopub.status.busy": "2024-08-16T06:32:53.036232Z", "iopub.status.idle": "2024-08-16T06:32:53.184845Z", "shell.execute_reply": "2024-08-16T06:32:53.183995Z" }, "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-08-16T06:32:53.188894Z", "iopub.status.busy": "2024-08-16T06:32:53.188627Z", "iopub.status.idle": "2024-08-16T06:32:53.191907Z", "shell.execute_reply": "2024-08-16T06:32:53.191314Z" }, "id": "S4PIDhoDLbsZ" }, "outputs": [], "source": [ "BUFFER_SIZE = 60000\n", "BATCH_SIZE = 256" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "execution": { "iopub.execute_input": "2024-08-16T06:32:53.194978Z", "iopub.status.busy": "2024-08-16T06:32:53.194725Z", "iopub.status.idle": "2024-08-16T06:32:55.906143Z", "shell.execute_reply": "2024-08-16T06:32:55.905444Z" }, "id": "-yKCCQOoJ7cn" }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", "I0000 00:00:1723789973.811300 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789973.815200 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789973.818846 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789973.822539 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789973.834632 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS ha" ] }, { "name": "stderr", "output_type": "stream", "text": [ "d negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789973.838150 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789973.841574 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789973.844956 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789973.848426 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789973.851903 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789973.855314 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789973.858808 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789975.100045 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789975.102173 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789975.104239 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789975.106192 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789975.108237 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789975.110183 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789975.112199 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789975.114071 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789975.116009 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789975.117945 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789975.120016 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789975.121872 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789975.159897 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789975.161930 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789975.163934 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789975.166367 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789975.168201 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789975.170159 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789975.172123 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789975.174004 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789975.175870 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789975.178408 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789975.180831 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "I0000 00:00:1723789975.183150 174689 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n" ] } ], "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-08-16T06:32:55.909709Z", "iopub.status.busy": "2024-08-16T06:32:55.909461Z", "iopub.status.idle": "2024-08-16T06:32:55.916374Z", "shell.execute_reply": "2024-08-16T06:32:55.915794Z" }, "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-08-16T06:32:55.919460Z", "iopub.status.busy": "2024-08-16T06:32:55.919235Z", "iopub.status.idle": "2024-08-16T06:32:57.342189Z", "shell.execute_reply": "2024-08-16T06:32:57.341343Z" }, "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:87: 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" ] }, { "name": "stderr", "output_type": "stream", "text": [ "W0000 00:00:1723789976.899989 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789976.926511 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789976.928496 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789976.929818 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789976.931337 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789976.971816 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789976.980776 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789976.999036 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.003393 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.032526 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.048252 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.049424 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.050581 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.051736 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.052917 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.054531 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "W0000 00:00:1723789977.109358 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.112654 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.121306 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.122470 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.123600 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.124762 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.125930 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.127257 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.128571 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.129815 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\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-08-16T06:32:57.345774Z", "iopub.status.busy": "2024-08-16T06:32:57.345495Z", "iopub.status.idle": "2024-08-16T06:32:57.351061Z", "shell.execute_reply": "2024-08-16T06:32:57.350236Z" }, "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-08-16T06:32:57.354335Z", "iopub.status.busy": "2024-08-16T06:32:57.354031Z", "iopub.status.idle": "2024-08-16T06:32:57.500096Z", "shell.execute_reply": "2024-08-16T06:32:57.499239Z" }, "id": "gDkA05NE6QMs" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tf.Tensor([[0.00357757]], 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:107: 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", "W0000 00:00:1723789977.415503 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.422830 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.426039 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.427237 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.428359 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.431492 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.432673 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.433841 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.435037 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.436201 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.454917 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.456118 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.457251 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.458415 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.468295 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.469644 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.471012 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.472515 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.474116 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.475706 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.477290 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.478837 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.480442 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.482068 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.483698 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.485061 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.486803 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.488627 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", "W0000 00:00:1723789977.489960 174689 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\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-08-16T06:32:57.503576Z", "iopub.status.busy": "2024-08-16T06:32:57.503309Z", "iopub.status.idle": "2024-08-16T06:32:57.507294Z", "shell.execute_reply": "2024-08-16T06:32:57.506464Z" }, "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-08-16T06:32:57.510537Z", "iopub.status.busy": "2024-08-16T06:32:57.510289Z", "iopub.status.idle": "2024-08-16T06:32:57.514512Z", "shell.execute_reply": "2024-08-16T06:32:57.513515Z" }, "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-08-16T06:32:57.518013Z", "iopub.status.busy": "2024-08-16T06:32:57.517769Z", "iopub.status.idle": "2024-08-16T06:32:57.521551Z", "shell.execute_reply": "2024-08-16T06:32:57.520716Z" }, "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-08-16T06:32:57.524992Z", "iopub.status.busy": "2024-08-16T06:32:57.524720Z", "iopub.status.idle": "2024-08-16T06:32:57.533903Z", "shell.execute_reply": "2024-08-16T06:32:57.533033Z" }, "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-08-16T06:32:57.537163Z", "iopub.status.busy": "2024-08-16T06:32:57.536913Z", "iopub.status.idle": "2024-08-16T06:32:57.541545Z", "shell.execute_reply": "2024-08-16T06:32:57.540721Z" }, "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-08-16T06:32:57.544891Z", "iopub.status.busy": "2024-08-16T06:32:57.544612Z", "iopub.status.idle": "2024-08-16T06:32:57.549427Z", "shell.execute_reply": "2024-08-16T06:32:57.548601Z" }, "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-08-16T06:32:57.552856Z", "iopub.status.busy": "2024-08-16T06:32:57.552612Z", "iopub.status.idle": "2024-08-16T06:32:57.559063Z", "shell.execute_reply": "2024-08-16T06:32:57.558200Z" }, "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-08-16T06:32:57.562101Z", "iopub.status.busy": "2024-08-16T06:32:57.561856Z", "iopub.status.idle": "2024-08-16T06:32:57.567177Z", "shell.execute_reply": "2024-08-16T06:32:57.566349Z" }, "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-08-16T06:32:57.570588Z", "iopub.status.busy": "2024-08-16T06:32:57.570323Z", "iopub.status.idle": "2024-08-16T06:32:57.575468Z", "shell.execute_reply": "2024-08-16T06:32:57.574502Z" }, "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-08-16T06:32:57.578834Z", "iopub.status.busy": "2024-08-16T06:32:57.578578Z", "iopub.status.idle": "2024-08-16T06:44:20.513797Z", "shell.execute_reply": "2024-08-16T06:44:20.513090Z" }, "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-08-16T06:44:20.517311Z", "iopub.status.busy": "2024-08-16T06:44:20.517053Z", "iopub.status.idle": "2024-08-16T06:44:20.590831Z", "shell.execute_reply": "2024-08-16T06:44:20.590175Z" }, "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-08-16T06:44:20.594108Z", "iopub.status.busy": "2024-08-16T06:44:20.593854Z", "iopub.status.idle": "2024-08-16T06:44:20.597342Z", "shell.execute_reply": "2024-08-16T06:44:20.596744Z" }, "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-08-16T06:44:20.600499Z", "iopub.status.busy": "2024-08-16T06:44:20.599954Z", "iopub.status.idle": "2024-08-16T06:44:20.615535Z", "shell.execute_reply": "2024-08-16T06:44:20.614982Z" }, "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-08-16T06:44:20.618960Z", "iopub.status.busy": "2024-08-16T06:44:20.618364Z", "iopub.status.idle": "2024-08-16T06:44:21.202896Z", "shell.execute_reply": "2024-08-16T06:44:21.202120Z" }, "id": "IGKQgENQ8lEI" }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_174689/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_174689/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-08-16T06:44:21.207070Z", "iopub.status.busy": "2024-08-16T06:44:21.206432Z", "iopub.status.idle": "2024-08-16T06:44:21.226514Z", "shell.execute_reply": "2024-08-16T06:44:21.225919Z" }, "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.19" } }, "nbformat": 4, "nbformat_minor": 0 }