{ "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": "2023-11-07T19:20:53.270746Z", "iopub.status.busy": "2023-11-07T19:20:53.270502Z", "iopub.status.idle": "2023-11-07T19:20:53.274769Z", "shell.execute_reply": "2023-11-07T19:20:53.274140Z" }, "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": [ "# 深度卷积生成对抗网络" ] }, { "cell_type": "markdown", "metadata": { "id": "0TD5ZrvEMbhZ" }, "source": [ "\n", " \n", " \n", " \n", " \n", "
在 TensorFlow.org上查看 在 Google Colab 中运行 在 GitHub 上查看源代码 下载笔记本
" ] }, { "cell_type": "markdown", "metadata": { "id": "ITZuApL56Mny" }, "source": [ "本教程演示了如何使用[深度卷积生成对抗网络](https://arxiv.org/pdf/1511.06434.pdf) (DCGAN) 生成手写数字的图像。该代码是使用 [Keras 序列式 API](https://tensorflow.google.cn/guide/keras) 与 `tf.GradientTape` 训练循环编写的。" ] }, { "cell_type": "markdown", "metadata": { "id": "2MbKJY38Puy9" }, "source": [ "## 什么是生成对抗网络？\n", "\n", "[生成对抗网络](https://arxiv.org/abs/1406.2661) (GAN) 是当今计算机科学领域最有趣的想法之一。两个模型通过对抗过程同时训练。*生成器*（“艺术家”）学习创建看起来真实的图像，而*判别器*（“艺术评论家”）学习区分真假图像。\n", "\n", "![生成器和判别器图示](https://github.com/tensorflow/docs/blob/master/site/en/tutorials/generative/images/gan1.png?raw=1)\n", "\n", "训练过程中，*生成器*在生成逼真图像方面逐渐变强，而*判别器*在辨别这些图像的能力上逐渐变强。当*判别器*不再能够区分真实图片和伪造图片时，训练过程达到平衡。\n", "\n", "![生成器和判别器图示二](https://github.com/tensorflow/docs/blob/master/site/en/tutorials/generative/images/gan2.png?raw=1)\n", "\n", "本笔记在 MNIST 数据集上演示了该过程。下方动画展示了当训练了 50 个epoch （全部数据集迭代50次） 时*生成器*所生成的一系列图片。图片从随机噪声开始，随着时间的推移越来越像手写数字。\n", "\n", "![输出样本](https://tensorflow.google.cn/images/gan/dcgan.gif)\n", "\n", "要详细了解 GAN，请参阅 MIT 的[深度学习介绍](http://introtodeeplearning.com/)课程。" ] }, { "cell_type": "markdown", "metadata": { "id": "e1_Y75QXJS6h" }, "source": [ "### Import TensorFlow and other libraries" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "execution": { "iopub.execute_input": "2023-11-07T19:20:53.278485Z", "iopub.status.busy": "2023-11-07T19:20:53.278106Z", "iopub.status.idle": "2023-11-07T19:20:55.659727Z", "shell.execute_reply": "2023-11-07T19:20:55.659030Z" }, "id": "WZKbyU2-AiY-" }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "2023-11-07 19:20:53.713258: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", "2023-11-07 19:20:53.713309: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", "2023-11-07 19:20:53.714908: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] 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": "2023-11-07T19:20:55.663741Z", "iopub.status.busy": "2023-11-07T19:20:55.663318Z", "iopub.status.idle": "2023-11-07T19:20:55.670152Z", "shell.execute_reply": "2023-11-07T19:20:55.669557Z" }, "id": "wx-zNbLqB4K8" }, "outputs": [ { "data": { "text/plain": [ "'2.15.0-rc1'" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tf.__version__" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "execution": { "iopub.execute_input": "2023-11-07T19:20:55.673415Z", "iopub.status.busy": "2023-11-07T19:20:55.673151Z", "iopub.status.idle": "2023-11-07T19:21:03.214865Z", "shell.execute_reply": "2023-11-07T19:21:03.213965Z" }, "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.32.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.1)\r\n", "Requirement already satisfied: pillow<10.1.0,>=8.3.2 in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from imageio) (10.0.1)\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-gu8yfs7i\r\n", " Running command git clone --filter=blob:none --quiet https://github.com/tensorflow/docs /tmpfs/tmp/pip-req-build-gu8yfs7i\r\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " Resolved https://github.com/tensorflow/docs to commit 60abeb06e500fa5edbbac374fc0d8142c8322aef\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==2023.10.27.81990)\r\n", " Using cached astor-0.8.1-py2.py3-none-any.whl (27 kB)\r\n", "Requirement already satisfied: absl-py in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from tensorflow-docs==2023.10.27.81990) (1.4.0)\r\n", "Requirement already satisfied: jinja2 in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from tensorflow-docs==2023.10.27.81990) (3.1.2)\r\n", "Requirement already satisfied: nbformat in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from tensorflow-docs==2023.10.27.81990) (5.9.2)\r\n", "Requirement already satisfied: protobuf>=3.12 in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from tensorflow-docs==2023.10.27.81990) (3.20.3)\r\n", "Requirement already satisfied: pyyaml in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from tensorflow-docs==2023.10.27.81990) (6.0.1)\r\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Requirement already satisfied: MarkupSafe>=2.0 in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from jinja2->tensorflow-docs==2023.10.27.81990) (2.1.3)\r\n", "Requirement already satisfied: fastjsonschema in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from nbformat->tensorflow-docs==2023.10.27.81990) (2.18.1)\r\n", "Requirement already satisfied: jsonschema>=2.6 in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from nbformat->tensorflow-docs==2023.10.27.81990) (4.19.2)\r\n", "Requirement already satisfied: jupyter-core in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from nbformat->tensorflow-docs==2023.10.27.81990) (5.5.0)\r\n", "Requirement already satisfied: traitlets>=5.1 in /tmpfs/src/tf_docs_env/lib/python3.9/site-packages (from nbformat->tensorflow-docs==2023.10.27.81990) (5.13.0)\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==2023.10.27.81990) (23.1.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==2023.10.27.81990) (2023.7.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==2023.10.27.81990) (0.30.2)\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==2023.10.27.81990) (0.12.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==2023.10.27.81990) (3.11.0)\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-2023.10.27.81990-py3-none-any.whl size=184142 sha256=d84ed92d29fafc0cf88e56ebd3dfcf18857660adc6b40515eafb811ee2fbe9ac\r\n", " Stored in directory: /tmpfs/tmp/pip-ephem-wheel-cache-ss2p6z0f/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-2023.10.27.81990\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": "2023-11-07T19:21:03.219019Z", "iopub.status.busy": "2023-11-07T19:21:03.218700Z", "iopub.status.idle": "2023-11-07T19:21:03.532380Z", "shell.execute_reply": "2023-11-07T19:21:03.531705Z" }, "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": [ "### 加载和准备数据集\n", "\n", "您将使用 MNIST 数据集来训练生成器和判别器。生成器将生成类似于 MNIST 数据集的手写数字。" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "execution": { "iopub.execute_input": "2023-11-07T19:21:03.536666Z", "iopub.status.busy": "2023-11-07T19:21:03.536053Z", "iopub.status.idle": "2023-11-07T19:21:03.812294Z", "shell.execute_reply": "2023-11-07T19:21:03.811540Z" }, "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": "2023-11-07T19:21:03.816482Z", "iopub.status.busy": "2023-11-07T19:21:03.815817Z", "iopub.status.idle": "2023-11-07T19:21:03.969426Z", "shell.execute_reply": "2023-11-07T19:21:03.968640Z" }, "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": "2023-11-07T19:21:03.973660Z", "iopub.status.busy": "2023-11-07T19:21:03.973364Z", "iopub.status.idle": "2023-11-07T19:21:03.976839Z", "shell.execute_reply": "2023-11-07T19:21:03.976169Z" }, "id": "S4PIDhoDLbsZ" }, "outputs": [], "source": [ "BUFFER_SIZE = 60000\n", "BATCH_SIZE = 256" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "execution": { "iopub.execute_input": "2023-11-07T19:21:03.980372Z", "iopub.status.busy": "2023-11-07T19:21:03.979855Z", "iopub.status.idle": "2023-11-07T19:21:06.636817Z", "shell.execute_reply": "2023-11-07T19:21:06.636007Z" }, "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": [ "## 创建模型\n", "\n", "生成器和判别器均使用 [Keras Sequential API](https://tensorflow.google.cn/guide/keras#sequential_model) 定义。" ] }, { "cell_type": "markdown", "metadata": { "id": "-tEyxE-GMC48" }, "source": [ "### 生成器\n", "\n", "生成器使用 `tf.keras.layers.Conv2DTranspose`（上采样）层来从种子（随机噪声）中生成图像。以一个使用该种子作为输入的 `Dense` 层开始，然后多次上采样，直至达到所需的 28x28x1 的图像大小。请注意，除了输出层使用双曲正切之外，其他每层均使用 `tf.keras.layers.LeakyReLU` 激活。" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "execution": { "iopub.execute_input": "2023-11-07T19:21:06.641090Z", "iopub.status.busy": "2023-11-07T19:21:06.640511Z", "iopub.status.idle": "2023-11-07T19:21:06.647761Z", "shell.execute_reply": "2023-11-07T19:21:06.647102Z" }, "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": [ "使用（尚未训练的）生成器创建一张图片。" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "execution": { "iopub.execute_input": "2023-11-07T19:21:06.650984Z", "iopub.status.busy": "2023-11-07T19:21:06.650461Z", "iopub.status.idle": "2023-11-07T19:21:07.759596Z", "shell.execute_reply": "2023-11-07T19:21:07.758924Z" }, "id": "gl7jcC7TdPTG" }, "outputs": [ { "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": [ "### 判别器\n", "\n", "判别器是一个基于 CNN 的图片分类器。" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "execution": { "iopub.execute_input": "2023-11-07T19:21:07.763148Z", "iopub.status.busy": "2023-11-07T19:21:07.762901Z", "iopub.status.idle": "2023-11-07T19:21:07.768407Z", "shell.execute_reply": "2023-11-07T19:21:07.767781Z" }, "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": [ "使用（尚未训练的）判别器对所生成的图像进行真伪分类。模型将被训练为对真实图像输出正值，对伪造图像输出负值。" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "execution": { "iopub.execute_input": "2023-11-07T19:21:07.771616Z", "iopub.status.busy": "2023-11-07T19:21:07.771372Z", "iopub.status.idle": "2023-11-07T19:21:08.006343Z", "shell.execute_reply": "2023-11-07T19:21:08.005410Z" }, "id": "gDkA05NE6QMs" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tf.Tensor([[6.968534e-05]], shape=(1, 1), dtype=float32)\n" ] } ], "source": [ "discriminator = make_discriminator_model()\n", "decision = discriminator(generated_image)\n", "print (decision)" ] }, { "cell_type": "markdown", "metadata": { "id": "0FMYgY_mPfTi" }, "source": [ "## 定义损失函数和优化器\n", "\n", "为两个模型定义损失函数和优化器。\n" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "execution": { "iopub.execute_input": "2023-11-07T19:21:08.009969Z", "iopub.status.busy": "2023-11-07T19:21:08.009715Z", "iopub.status.idle": "2023-11-07T19:21:08.013261Z", "shell.execute_reply": "2023-11-07T19:21:08.012598Z" }, "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": [ "### 判别器损失\n", "\n", "该方法量化判别器从判断真伪图片的能力。它将判别器对真实图片的预测值与值全为 1 的数组进行对比，将判别器对伪造（生成的）图片的预测值与值全为 0 的数组进行对比。" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "execution": { "iopub.execute_input": "2023-11-07T19:21:08.016450Z", "iopub.status.busy": "2023-11-07T19:21:08.016189Z", "iopub.status.idle": "2023-11-07T19:21:08.019820Z", "shell.execute_reply": "2023-11-07T19:21:08.019176Z" }, "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": [ "### 生成器损失\n", "\n", "生成器的损失可量化其欺骗判别器的能力。直观地说，如果生成器表现良好，判别器会将伪造图像分类为真实图像（或 1）。在此，需要将判别器对生成图像的决策与值全为 1 的数组进行对比。" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "execution": { "iopub.execute_input": "2023-11-07T19:21:08.022902Z", "iopub.status.busy": "2023-11-07T19:21:08.022687Z", "iopub.status.idle": "2023-11-07T19:21:08.025904Z", "shell.execute_reply": "2023-11-07T19:21:08.025231Z" }, "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": [ "判别器和生成器优化器不同，因为您将分别训练两个网络。" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "execution": { "iopub.execute_input": "2023-11-07T19:21:08.029421Z", "iopub.status.busy": "2023-11-07T19:21:08.029186Z", "iopub.status.idle": "2023-11-07T19:21:08.036562Z", "shell.execute_reply": "2023-11-07T19:21:08.035893Z" }, "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": [ "### 保存检查点\n", "\n", "本笔记还演示了如何保存和恢复模型，这在长时间训练任务被中断的情况下比较有帮助。" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "execution": { "iopub.execute_input": "2023-11-07T19:21:08.040154Z", "iopub.status.busy": "2023-11-07T19:21:08.039632Z", "iopub.status.idle": "2023-11-07T19:21:08.043841Z", "shell.execute_reply": "2023-11-07T19:21:08.043230Z" }, "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": [ "## 定义训练循环\n" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "execution": { "iopub.execute_input": "2023-11-07T19:21:08.046815Z", "iopub.status.busy": "2023-11-07T19:21:08.046587Z", "iopub.status.idle": "2023-11-07T19:21:08.050618Z", "shell.execute_reply": "2023-11-07T19:21:08.050002Z" }, "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": [ "训练循环在生成器接收到一个随机种子作为输入时开始。该种子用于生成一个图像。判别器随后被用于对真实图像（选自训练集）和伪造图像（由生成器生成）进行分类。为每一个模型计算损失，并使用梯度更新生成器和判别器。" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "execution": { "iopub.execute_input": "2023-11-07T19:21:08.053876Z", "iopub.status.busy": "2023-11-07T19:21:08.053637Z", "iopub.status.idle": "2023-11-07T19:21:08.059270Z", "shell.execute_reply": "2023-11-07T19:21:08.058701Z" }, "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": "2023-11-07T19:21:08.062244Z", "iopub.status.busy": "2023-11-07T19:21:08.062007Z", "iopub.status.idle": "2023-11-07T19:21:08.066784Z", "shell.execute_reply": "2023-11-07T19:21:08.066146Z" }, "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": [ "**生成与保存图片**\n" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "execution": { "iopub.execute_input": "2023-11-07T19:21:08.070225Z", "iopub.status.busy": "2023-11-07T19:21:08.069680Z", "iopub.status.idle": "2023-11-07T19:21:08.074137Z", "shell.execute_reply": "2023-11-07T19:21:08.073545Z" }, "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": [ "## 训练模型\n", "\n", "调用上面定义的 `train()` 方法来同时训练生成器和判别器。注意，训练 GANs 可能是棘手的。重要的是，生成器和判别器不能够互相压制对方（例如，他们以相似的学习率训练）。\n", "\n", "在训练之初，生成的图片看起来像是随机噪声。随着训练过程的进行，生成的数字将越来越真实。在大概 50 个 epoch 之后，这些图片看起来像是 MNIST 数字。使用 Colab 中的默认设置可能需要大约 1 分钟每 epoch。" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "execution": { "iopub.execute_input": "2023-11-07T19:21:08.077273Z", "iopub.status.busy": "2023-11-07T19:21:08.077058Z", "iopub.status.idle": "2023-11-07T19:30:07.641062Z", "shell.execute_reply": "2023-11-07T19:30:07.640048Z" }, "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": [ "恢复最新的检查点。" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "execution": { "iopub.execute_input": "2023-11-07T19:30:07.644801Z", "iopub.status.busy": "2023-11-07T19:30:07.644525Z", "iopub.status.idle": "2023-11-07T19:30:07.715073Z", "shell.execute_reply": "2023-11-07T19:30:07.714002Z" }, "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": [ "## 创建 GIF\n" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "execution": { "iopub.execute_input": "2023-11-07T19:30:07.719014Z", "iopub.status.busy": "2023-11-07T19:30:07.718392Z", "iopub.status.idle": "2023-11-07T19:30:07.722272Z", "shell.execute_reply": "2023-11-07T19:30:07.721436Z" }, "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": "2023-11-07T19:30:07.725514Z", "iopub.status.busy": "2023-11-07T19:30:07.724898Z", "iopub.status.idle": "2023-11-07T19:30:08.381251Z", "shell.execute_reply": "2023-11-07T19:30:08.380382Z" }, "id": "5x3q9_Oe5q0A" }, "outputs": [ { "ename": "ValueError", "evalue": "Could not save to JPEG for display", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", "File \u001b[0;32m/tmpfs/src/tf_docs_env/lib/python3.9/site-packages/PIL/JpegImagePlugin.py:639\u001b[0m, in \u001b[0;36m_save\u001b[0;34m(im, fp, filename)\u001b[0m\n\u001b[1;32m 638\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 639\u001b[0m rawmode \u001b[38;5;241m=\u001b[39m \u001b[43mRAWMODE\u001b[49m\u001b[43m[\u001b[49m\u001b[43mim\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmode\u001b[49m\u001b[43m]\u001b[49m\n\u001b[1;32m 640\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n", "\u001b[0;31mKeyError\u001b[0m: 'RGBA'", "\nThe above exception was the direct cause of the following exception:\n", "\u001b[0;31mOSError\u001b[0m Traceback (most recent call last)", "File \u001b[0;32m/tmpfs/src/tf_docs_env/lib/python3.9/site-packages/PIL/Image.py:643\u001b[0m, in \u001b[0;36mImage._repr_image\u001b[0;34m(self, image_format, **kwargs)\u001b[0m\n\u001b[1;32m 642\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 643\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msave\u001b[49m\u001b[43m(\u001b[49m\u001b[43mb\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mimage_format\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 644\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n", "File \u001b[0;32m/tmpfs/src/tf_docs_env/lib/python3.9/site-packages/PIL/Image.py:2413\u001b[0m, in \u001b[0;36mImage.save\u001b[0;34m(self, fp, format, **params)\u001b[0m\n\u001b[1;32m 2412\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 2413\u001b[0m \u001b[43msave_handler\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfp\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfilename\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2414\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n", "File \u001b[0;32m/tmpfs/src/tf_docs_env/lib/python3.9/site-packages/PIL/JpegImagePlugin.py:642\u001b[0m, in \u001b[0;36m_save\u001b[0;34m(im, fp, filename)\u001b[0m\n\u001b[1;32m 641\u001b[0m msg \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcannot write mode \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mim\u001b[38;5;241m.\u001b[39mmode\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m as JPEG\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m--> 642\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mOSError\u001b[39;00m(msg) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01me\u001b[39;00m\n\u001b[1;32m 644\u001b[0m info \u001b[38;5;241m=\u001b[39m im\u001b[38;5;241m.\u001b[39mencoderinfo\n", "\u001b[0;31mOSError\u001b[0m: cannot write mode RGBA as JPEG", "\nThe above exception was the direct cause of the following exception:\n", "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", "File \u001b[0;32m/tmpfs/src/tf_docs_env/lib/python3.9/site-packages/IPython/core/formatters.py:344\u001b[0m, in \u001b[0;36mBaseFormatter.__call__\u001b[0;34m(self, obj)\u001b[0m\n\u001b[1;32m 342\u001b[0m method \u001b[38;5;241m=\u001b[39m get_real_method(obj, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprint_method)\n\u001b[1;32m 343\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m method \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 344\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mmethod\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 345\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 346\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", "File \u001b[0;32m/tmpfs/src/tf_docs_env/lib/python3.9/site-packages/PIL/Image.py:661\u001b[0m, in \u001b[0;36mImage._repr_jpeg_\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 656\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_repr_jpeg_\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m 657\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"iPython display hook support for JPEG format.\u001b[39;00m\n\u001b[1;32m 658\u001b[0m \n\u001b[1;32m 659\u001b[0m \u001b[38;5;124;03m :returns: JPEG version of the image as bytes\u001b[39;00m\n\u001b[1;32m 660\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 661\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_repr_image\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mJPEG\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n", "File \u001b[0;32m/tmpfs/src/tf_docs_env/lib/python3.9/site-packages/PIL/Image.py:646\u001b[0m, in \u001b[0;36mImage._repr_image\u001b[0;34m(self, image_format, **kwargs)\u001b[0m\n\u001b[1;32m 644\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 645\u001b[0m msg \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCould not save to \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mimage_format\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m for display\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m--> 646\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(msg) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01me\u001b[39;00m\n\u001b[1;32m 647\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m b\u001b[38;5;241m.\u001b[39mgetvalue()\n", "\u001b[0;31mValueError\u001b[0m: Could not save to JPEG for display" ] }, { "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": [ "使用训练过程中生成的图片通过 `imageio` 生成动态 gif" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "execution": { "iopub.execute_input": "2023-11-07T19:30:08.384630Z", "iopub.status.busy": "2023-11-07T19:30:08.384357Z", "iopub.status.idle": "2023-11-07T19:30:08.860196Z", "shell.execute_reply": "2023-11-07T19:30:08.859466Z" }, "id": "IGKQgENQ8lEI" }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmpfs/tmp/ipykernel_435330/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_435330/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": "2023-11-07T19:30:08.864385Z", "iopub.status.busy": "2023-11-07T19:30:08.863656Z", "iopub.status.idle": "2023-11-07T19:30:08.884287Z", "shell.execute_reply": "2023-11-07T19:30:08.883473Z" }, "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": [ "## 下一步\n" ] }, { "cell_type": "markdown", "metadata": { "id": "xjjkT9KAK6H7" }, "source": [ "本教程展示了编写和训练 GAN 所需的完整代码。下一步，您可能想尝试不同的数据集，例如 [Kaggle 上提供的](https://www.kaggle.com/jessicali9530/celeba-dataset) Large-scale Celeb Faces Attributes (CelebA) 人脸识别数据集。要详细了解 GAN，请参阅 [NIPS 2016 教程：生成对抗网络](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 }