1-4-DCGAN.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/JSJeong-me/AI-Innovation-2024/blob/main/1-4-DCGAN.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_jQ1tEQCxwRx"
      },
      "source": [
        "##### Copyright 2019 The TensorFlow Authors."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "cellView": "form",
        "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": [
        "<table class=\"tfo-notebook-buttons\" align=\"left\">\n",
        "  <td>     <a target=\"_blank\" href=\"https://www.tensorflow.org/tutorials/generative/dcgan\">     <img src=\"https://www.tensorflow.org/images/tf_logo_32px.png\">     TensorFlow.org에서 보기</a>   </td>\n",
        "  <td><a target=\"_blank\" href=\"https://colab.research.google.com/github/tensorflow/docs-l10n/blob/master/site/ko/tutorials/generative/dcgan.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\">Google Colab에서 실행</a></td>\n",
        "  <td><a target=\"_blank\" href=\"https://github.com/tensorflow/docs-l10n/blob/master/site/ko/tutorials/generative/dcgan.ipynb\"><img src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\">GitHub에서 소스 보기</a></td>\n",
        "  <td><a href=\"https://storage.googleapis.com/tensorflow_docs/docs-l10n/site/ko/tutorials/generative/dcgan.ipynb\"><img src=\"https://www.tensorflow.org/images/download_logo_32px.png\">노트북 다운로드</a></td>\n",
        "</table>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ITZuApL56Mny"
      },
      "source": [
        "이 튜토리얼은 [딥 컨볼루셔널 생성적 적대 신경망(Deep Convolutional Generative Adversarial Networks, DCGAN)](https://arxiv.org/pdf/1511.06434.pdf)을 이용하여 손으로 쓴 숫자의 이미지를 생성하는 방법을 보여줍니다. 이 코드는 [Keras Sequential API](https://www.tensorflow.org/guide/keras) 및 `tf.GradientTape` 훈련 루프를 사용하여 작성되었습니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2MbKJY38Puy9"
      },
      "source": [
        "## 생성적 적대 신경망(GAN)이란?\n",
        "\n",
        "[생성적 적대 신경망(Generative Adversarial Networks, GAN)](https://arxiv.org/abs/1406.2661)은 최근 컴퓨터 과학에서 가장 흥미로운 아이디어 중 하나입니다. 두 개의 모델이 적대적인 과정을 통해 동시에 훈련됩니다. *생성자*(\"예술가\")는 진짜처럼 보이는 이미지 생성을 학습하고, *감별자*(\"예술비평가\")는 가짜의 이미지를 진짜 이미지와 구별하는 방식을 학습합니다.\n",
        "\n",
        "![생성자와 감별자를 그린 도표](https://tensorflow.org/tutorials/generative/images/gan1.png)\n",
        "\n",
        "훈련과정 동안 *생성자*는 점차 실제같은 이미지를 더 잘 생성하게 되고, *감별자*는 점차 진짜와 가짜를 더 잘 구별하게됩니다. 이 과정은 *감별자*가 가짜 이미지에서 진짜 이미지를 더이상 구별하지 못하게 될때, 평형상태에 도달하게 됩니다.\n",
        "\n",
        "![생성자와 감별자를 그린 두번째 도표](https://tensorflow.org/tutorials/generative/images/gan2.png)\n",
        "\n",
        "이 노트북은 이 과정을 MNIST 데이터세트를 이용하여 보여줍니다. 아래의 애니메이션에는 50 epoch 동안 훈련한 *생성자*를 통해 생성된 연속적 이미지가 표시됩니다. 해당 이미지는 임의의 노이즈에서 시작되어, 점차 손으로 쓴 숫자를 닮아갑니다.\n",
        "\n",
        "![출력 예시](https://tensorflow.org/images/gan/dcgan.gif)\n",
        "\n",
        "GAN에 대해 자세히 알아보려면 MIT의 [Intro to Deep Learning](http://introtodeeplearning.com/) 과정을 참조하십시오."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e1_Y75QXJS6h"
      },
      "source": [
        "### 텐서플로와 다른 라이브러리 불러오기"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "WZKbyU2-AiY-"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "wx-zNbLqB4K8",
        "outputId": "83165350-646b-43d0-d4e9-a93c201762ae",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'2.17.0'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 3
        }
      ],
      "source": [
        "tf.__version__"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "YzTlj4YdCip_",
        "outputId": "6a4b3948-f74f-4918-b66d-5a9a083404f7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: imageio in /usr/local/lib/python3.10/dist-packages (2.34.2)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from imageio) (1.26.4)\n",
            "Requirement already satisfied: pillow>=8.3.2 in /usr/local/lib/python3.10/dist-packages (from imageio) (9.4.0)\n"
          ]
        }
      ],
      "source": [
        "# GIF를 만들기위해 설치합니다.\n",
        "!pip install imageio"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "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 데이터셋을 사용할것입니다. 생성자는 손글씨 숫자 데이터를 닮은 숫자들을 생성할 것입니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "a4fYMGxGhrna",
        "outputId": "fdc7dd6c-ecdc-491b-91c9-bca93e44ecc2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz\n",
            "\u001b[1m11490434/11490434\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 0us/step\n"
          ]
        }
      ],
      "source": [
        "(train_images, train_labels), (_, _) = tf.keras.datasets.mnist.load_data()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "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 # 이미지를 [-1, 1]로 정규화합니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "S4PIDhoDLbsZ"
      },
      "outputs": [],
      "source": [
        "BUFFER_SIZE = 60000\n",
        "BATCH_SIZE = 256"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "-yKCCQOoJ7cn"
      },
      "outputs": [],
      "source": [
        "# 데이터 배치를 만들고 섞습니다.\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",
        "생성자와 감별자는 [케라스 Sequential API](https://www.tensorflow.org/guide/keras#sequential_model)를 이용해 정의됩니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-tEyxE-GMC48"
      },
      "source": [
        "### 생성자\n",
        "\n",
        "생성자는 시드값(임의의 노이즈)에서 이미지를 생성하기 위해, `tf.keras.layers.Conv2DTranspose`(업샘플링) 레이어를 이용합니다. 처음 `Dense` 레이어는 해당 시드값을 입력값으로 받습니다. 다음으로 원하는 크기인 28x28x1의 이미지에 도달할 때까지 업샘플링을 여러 번 수행합니다. tanh 함수를 사용하는 출력 레이어를 제외한 각 레이어에서 `tf.keras.layers.LeakyReLU` 활성화가 사용됩니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "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) # 주목: 배치사이즈로 None이 주어집니다.\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": {
        "id": "gl7jcC7TdPTG",
        "outputId": "ac650619-dbb4-49bc-9e39-2fbb5e59045f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 506
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-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"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7cc3cdcbaa70>"
            ]
          },
          "metadata": {},
          "execution_count": 11
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaAAAAGdCAYAAABU0qcqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAo+0lEQVR4nO3de3DV9Z3/8VcI5CRAcjCE3CDBcFe5qChIFaQSuWitKN3F1mnBVRlocFdpVxdbwcvuZpfOiNMOwnbditai1l2EgbV4AROkXOQiC4wYCAQBcwEiOQm5nMTk+/uDIT+jIHl/Tfgk8fmYOTMk+bz4fvLlm7w4yTnvE+F5nicAAC6xTq43AAD4bqKAAABOUEAAACcoIACAExQQAMAJCggA4AQFBABwggICADjR2fUGvqqhoUGFhYWKjY1VRESE6+0AAIw8z1NFRYVSU1PVqdOF7+e0uQIqLCxUWlqa620AAL6lY8eOqU+fPhf8eJsroNjYWEnSr371K0VHRzc716VLF/OxwuGwOSNJ8fHx5kx1dbU5U1paas6kpKSYM37OnSQVFxebM927d78kGb8Tpvbu3WvOxMTEmDN+/p2ioqLMmVOnTpkzkhQZGWnO+PmJheVr/JxQKGTOfPHFF+aMJAUCAXPmqquuMmc+//xzc+bw4cPmjCT16NHDnElMTDStr66u1iOPPNL4/fxCWq2AlixZot/85jcqLi7WiBEj9Lvf/U6jRo26aO7cRRwdHd3qBeT3R3x+vuH44efi97M3vwXk55uHn/35yfgtID/n3E/Gz7m7VMeR2nYB+fmPY11dnTkj+dtf165dzRk//0H1cz1Il+7rVrr4NdEqD0J4/fXXNW/ePC1cuFC7du3SiBEjNGnSJJ04caI1DgcAaIdapYCeffZZPfjgg7rvvvt05ZVXatmyZeratav+8Ic/tMbhAADtUIsXUG1trXbu3KnMzMz/f5BOnZSZmaktW7Z8bX04HFZ5eXmTGwCg42vxAjp16pTq6+uVlJTU5P1JSUnn/aV1dna2gsFg441HwAHAd4PzJ6LOnz9foVCo8Xbs2DHXWwIAXAIt/ii4hIQERUZGqqSkpMn7S0pKlJyc/LX1gUDA96M5AADtV4vfA4qKitLIkSO1fv36xvc1NDRo/fr1GjNmTEsfDgDQTrXK84DmzZunGTNm6LrrrtOoUaP03HPPqbKyUvfdd19rHA4A0A61SgFNnz5dJ0+e1IIFC1RcXKyrr75a69at+9oDEwAA312tNglh7ty5mjt3ru98fX296uvrm73ezzO3U1NTzRlJ5/1d1sXs3r3bnPHzzHI/JX/w4EFzRvL3jOqioiJzxs+zsIPBoDkj+Ruj4mfqgp9xKH6ucT/PsJekTz75xJyZNm2aOXP69Glzxs81VFFRYc5IavJ0kuYqLCw0Z/w8+Kpv377mjCR169bNnMnPzzetb+60CuePggMAfDdRQAAAJyggAIATFBAAwAkKCADgBAUEAHCCAgIAOEEBAQCcoIAAAE5QQAAAJyggAIATFBAAwIlWG0b6bUVGRpqGL371BfCao6GhwZyR/A2f9LO/AQMGmDN79+41Z3r27GnO+OVngGJtba0542fYpyR17drVnHnnnXfMGT9DT9PT082ZM2fOmDOS1L17d3Nm5cqV5sz9999vzvgZRlpcXGzOSNJHH31kzgwePNic8bM/P9eDJO3atcucycjIMK1v7hBc7gEBAJyggAAATlBAAAAnKCAAgBMUEADACQoIAOAEBQQAcIICAgA4QQEBAJyggAAATlBAAAAnKCAAgBMUEADAiTY7Dbuurs40DTsqKsp8DD/TpiUpLy/PnLnsssvMmU2bNpkzV1xxhTnjZ1K3JBUWFpozfiaQX3311ebMZ599Zs5IUq9evcyZlJQUcyYmJsac8TPFuE+fPuaM5G+i8759+8yZ999/35zxc+78TsO+4YYbzBk/k9hvvPFGc8by/fHL/HyP6N27t2l9VVVVs9ZxDwgA4AQFBABwggICADhBAQEAnKCAAABOUEAAACcoIACAExQQAMAJCggA4AQFBABwggICADhBAQEAnGizw0jr6+tVX1/f7PXx8fHmY4RCIXNGkmlf3+ZYP//5z82Z1atXmzOZmZnmjORvGGnXrl3NmQ0bNpgz3/ve98wZSSotLTVnPv30U3PmyiuvNGcuv/xyc2br1q3mjCQdOXLEnHnnnXfMmXHjxpkz0dHR5szAgQPNGUmqrKw0Z+rq6syZnTt3mjMjR440ZyR/X7f79+83rQ+Hw81axz0gAIATFBAAwAkKCADgBAUEAHCCAgIAOEEBAQCcoIAAAE5QQAAAJyggAIATFBAAwAkKCADgBAUEAHCizQ4jtfIz5NLzPF/Hio2NNWfKysrMmfz8fHPmpptuMmf86tWrlznzwQcfmDNPPvmkOVNUVGTOSNIDDzxgztx6663mTG1trTmze/duc2bs2LHmjCTl5eWZM0888YQ5c/jwYXNm79695szBgwfNGcnf+fvBD35gzpw8edKc6datmzkjSXfeeac5895775nW19TUNGsd94AAAE5QQAAAJ1q8gJ588klFREQ0uQ0ZMqSlDwMAaOda5XdAV111VZOfGXbu3GF+1QQAaCGt0gydO3dWcnJya/zVAIAOolV+B3Tw4EGlpqaqX79+uvfee3X06NELrg2HwyovL29yAwB0fC1eQKNHj9by5cu1bt06LV26VAUFBRo7dqwqKirOuz47O1vBYLDxlpaW1tJbAgC0QS1eQFOmTNHf/M3faPjw4Zo0aZLeeustlZWV6c9//vN518+fP1+hUKjxduzYsZbeEgCgDWr1Rwf06NFDgwYNuuCTKgOBgAKBQGtvAwDQxrT684DOnDmjQ4cOKSUlpbUPBQBoR1q8gH75y18qNzdXR44c0ebNm3XXXXcpMjJSP/7xj1v6UACAdqzFfwR3/Phx/fjHP1Zpaal69eqlm266SVu3bvU1NwwA0HFFeH4ncraS8vJyBYNBLViwQNHR0c3O+RnC+X//93/mjORvsGhMTIw5M3DgQHPm5ZdfNmdGjRplzkhSMBg0Z/wMhezdu7c5M2DAAHNGkvr372/OLF682Jzp06ePOTN8+HBz5vTp0+aMJFVVVZkzlq/Xc+rr680ZP0/V+OKLL8wZyd+Q43A4bM74+f5w4sQJc0aSDh06ZM50797dtL62tlYvvfSSQqGQ4uLiLriOWXAAACcoIACAExQQAMAJCggA4AQFBABwggICADhBAQEAnKCAAABOUEAAACcoIACAExQQAMAJCggA4ESrvyCdX926dTMN6Pv9739vPsZVV11lzkj+Bgf27NnTnDly5Ig542coq5+Bi5LUubP98omIiDBnCgsLzRk/g1wlKT093ZzxM8DUz/XgZ9DsDTfcYM5IUm5urjljHVgp+buG/vZv/9ac8Tt4eMqUKebMpk2bzJkrr7zSnFm2bJk5I0lPPfWUr5xFVVWVXnrppYuu4x4QAMAJCggA4AQFBABwggICADhBAQEAnKCAAABOUEAAACcoIACAExQQAMAJCggA4AQFBABwggICADhBAQEAnGiz07ArKytVX1/f7PVdunQxH6O0tNSckaSbb77ZnDl27Jg5s3//fnMmLi7OnImMjDRnJGnGjBnmzObNm82Zzz77zJzp1q2bOSNJffr0MWeCwaA5k5CQYM74mQK9cuVKc0aSJk6caM7Ex8ebM7169TJn1q9fb84cPnzYnJH8TW/3cw298sor5szChQvNGenspGqrsrIy0/qamppmreMeEADACQoIAOAEBQQAcIICAgA4QQEBAJyggAAATlBAAAAnKCAAgBMUEADACQoIAOAEBQQAcIICAgA40WaHkaanp6tr167NXh8Oh83H8DM8UZL27t1rzqSlpZkzEyZMMGf8DGWtra01ZyR/Ax6feeYZc+b11183Z/wM+5Sk4uJicyYnJ8ec8XM9/N3f/Z05c+DAAXNGkgYPHmzO+BnuW1lZac5ce+215kwoFDJnJOn06dPmTEVFhTlz3XXXmTN+vudJUnJysjlj/b7S3IGn3AMCADhBAQEAnKCAAABOUEAAACcoIACAExQQAMAJCggA4AQFBABwggICADhBAQEAnKCAAABOUEAAACfa7DDSY8eOKTo6utnrY2JizMc4deqUOSNJDzzwgDmzceNGc+b3v/+9OeNnEOK9995rzkjSjh07zJny8nJzpr6+3pxZuHChOSNJzz//vDkzdOhQc+bjjz82Z1auXGnOHD9+3JyRzg4DtvLzOf3oRz8yZ06ePGnO+LmGJKmhocGcSUpKMme6d+9uzuTn55szkvSXv/zFnImLizOtb+6AY+4BAQCcoIAAAE6YC2jjxo264447lJqaqoiICK1atarJxz3P04IFC5SSkqKYmBhlZmbq4MGDLbVfAEAHYS6gyspKjRgxQkuWLDnvxxctWqTf/va3WrZsmbZt26Zu3bpp0qRJqqmp+dabBQB0HOYHIUyZMkVTpkw578c8z9Nzzz2nX//617rzzjslSS+//LKSkpK0atUq3XPPPd9utwCADqNFfwdUUFCg4uJiZWZmNr4vGAxq9OjR2rJly3kz4XBY5eXlTW4AgI6vRQuouLhY0tcfhpiUlNT4sa/Kzs5WMBhsvKWlpbXklgAAbZTzR8HNnz9foVCo8Xbs2DHXWwIAXAItWkDJycmSpJKSkibvLykpafzYVwUCAcXFxTW5AQA6vhYtoIyMDCUnJ2v9+vWN7ysvL9e2bds0ZsyYljwUAKCdMz8K7syZM01GQBQUFGj37t2Kj49Xenq6Hn74Yf3zP/+zBg4cqIyMDD3xxBNKTU3V1KlTW3LfAIB2zlxAO3bs0Pe///3Gt+fNmydJmjFjhpYvX65HH31UlZWVmjVrlsrKynTTTTdp3bp1prluAICOL8LzPM/1Jr6svLxcwWBQTzzxhKm09uzZYz7WzTffbM5IUkREhDkzZMgQc8bPIEk/Uyf8DDCVpGuuucacqaqqMmeaO9jwy778Y2ALP89VO3r0qDlz2223mTNHjhwxZwoKCswZyd/5mzlzpjmzbds2c+auu+4yZ/wMzpWkTz/91Jw5cOCAOXOh51Z+kz/+8Y/mjCT98Ic/NGcCgYBpfU1NjR577DGFQqFv/L2+80fBAQC+myggAIATFBAAwAkKCADgBAUEAHCCAgIAOEEBAQCcoIAAAE5QQAAAJyggAIATFBAAwAkKCADgBAUEAHDC/HIMl0qXLl3UpUuXZq+/9tprzccoLS01ZyQpISHBnNm5c6c589VXlm2O9PR0c8bvVPCamhpzJjY21pyprq42Z6ZPn27OSNLAgQPNmU8++cSc+cMf/mDODB061JzJy8szZyTplltuMWc2b95szkybNs2c8TMl/suvYWbh5/uKn+ny4XDYnHnooYfMGUkKBoPmzPbt203rm/u9gXtAAAAnKCAAgBMUEADACQoIAOAEBQQAcIICAgA4QQEBAJyggAAATlBAAAAnKCAAgBMUEADACQoIAOBEmx1GGh8fr5iYmGavj4qKMh8jMjLSnJHsg/kkafz48eZM//79zZn33nvPnAkEAuaMJO3fv9+cOX36tDnj59/Jz7mTpKKiInPGz6DLV155xZzZsWOHOfP555+bM5L0L//yL+bM7bffbs6888475oyfgbGHDx82ZyTpww8/NGdSU1PNma5du5ozmzZtMmck6Z/+6Z/MGev318rKymat4x4QAMAJCggA4AQFBABwggICADhBAQEAnKCAAABOUEAAACcoIACAExQQAMAJCggA4AQFBABwggICADjRZoeRnjx5UtHR0c1e37t3b1/H8KO2ttac8TNIct++feZMdXW1OTNo0CBzRvI3xNQyYPac+Ph4c2bs2LHmjCRt3brVnKmpqTFnZs6cac74OQ8VFRXmjCTNmTPHnPn444/NmZEjR5oz4XDYnHn66afNGUlaunSpOZOQkGDOTJs2zZzp0aOHOSNJK1euNGes11Fzvya4BwQAcIICAgA4QQEBAJyggAAATlBAAAAnKCAAgBMUEADACQoIAOAEBQQAcIICAgA4QQEBAJyggAAATrTZYaQJCQmmwZV/+ctfzMe46667zBlJ+s///E9z5plnnjFnSkpKzJlOnez/pygoKDBnJCk9Pd2cCYVC5oyf4Y4rVqwwZyTpvvvuM2ciIyN9HcvqwIED5sztt9/u61irV682Z/wMp33nnXfMGT/XkJ9rVZJuu+02c8bPv9MLL7xgzhw9etSckaSf/exn5szu3btN65s7FJl7QAAAJyggAIAT5gLauHGj7rjjDqWmpioiIkKrVq1q8vGZM2cqIiKiyW3y5MkttV8AQAdhLqDKykqNGDFCS5YsueCayZMnq6ioqPH26quvfqtNAgA6HvODEKZMmaIpU6Z845pAIKDk5GTfmwIAdHyt8jugnJwcJSYmavDgwZozZ45KS0svuDYcDqu8vLzJDQDQ8bV4AU2ePFkvv/yy1q9fr3//939Xbm6upkyZovr6+vOuz87OVjAYbLylpaW19JYAAG1Qiz8P6J577mn887BhwzR8+HD1799fOTk5mjBhwtfWz58/X/PmzWt8u7y8nBICgO+AVn8Ydr9+/ZSQkKD8/PzzfjwQCCguLq7JDQDQ8bV6AR0/flylpaVKSUlp7UMBANoR84/gzpw50+TeTEFBgXbv3q34+HjFx8frqaee0rRp05ScnKxDhw7p0Ucf1YABAzRp0qQW3TgAoH0zF9COHTv0/e9/v/Htc7+/mTFjhpYuXao9e/bopZdeUllZmVJTUzVx4kQ988wzvuZEAQA6LnMBjR8/Xp7nXfDjb7/99rfa0DmhUEjhcLjZ64cOHWo+xsmTJ80Z6WzZWh08eNCcGTBggDnTt29fc8bP0FNJysjIMGe6du1qznz66afmTK9evcwZyd9QyJtvvtmc+fDDD82Z2bNnmzMNDQ3mjCStX7/enPnBD35gzgwZMsScKS4uNmdeeuklc0by9/U0YsQIc8bP900/A5glKRgMmjPdu3c3ra+pqWnWOmbBAQCcoIAAAE5QQAAAJyggAIATFBAAwAkKCADgBAUEAHCCAgIAOEEBAQCcoIAAAE5QQAAAJyggAIATFBAAwIkWf0nulhIOhxUREdHs9cOGDTMfo7S01JyRpP79+5szH3zwgTmzevVqc+aOO+4wZ372s5+ZM5K0aNEic2bv3r3mzKOPPmrO+JnmLEmLFy82Z7Zv3+7rWFbPPvusOeNnYrkk3XbbbeZMz549zZkDBw6YM2VlZebMnDlzzBlJKiwsNGc2bNhgzviZEu/3c4qMjDRnTp06ZVrf3Fcy4B4QAMAJCggA4AQFBABwggICADhBAQEAnKCAAABOUEAAACcoIACAExQQAMAJCggA4AQFBABwggICADjRZoeRJiYmKiYmptnrN27caD5GfX29OSNJdXV15kznzvZT/fjjj5szfoae5ufnmzOSdO2115ozo0ePNmdqamouSUaSXnvtNXNm7dq15kxmZqY588Mf/tCcWbBggTkj+btei4uLzZkBAwaYMykpKeZMcnKyOSNJa9asMWf8/NuWlJSYM37+jSTpk08+MWes57yhoaFZ67gHBABwggICADhBAQEAnKCAAABOUEAAACcoIACAExQQAMAJCggA4AQFBABwggICADhBAQEAnKCAAABOtNlhpJ06dVKnTs3vx8TERPMx/A6s3L59uznzxRdfmDPPPPOMOTN27Fhzxs+QS0maOnWqOTNy5Ehz5vbbbzdnfvSjH5kzkkzX3Dl+Bqz6GcL5P//zP+ZMenq6OSP52184HDZnDh48aM4MHjzYnPnss8/MGUk6c+aMOeNnKGttba05s2TJEnNGkn71q1+ZM9brobKyUv/6r/960XXcAwIAOEEBAQCcoIAAAE5QQAAAJyggAIATFBAAwAkKCADgBAUEAHCCAgIAOEEBAQCcoIAAAE5QQAAAJ9rsMNL8/HwFAoFmr/czCLFv377mjCT16NHDnBk1apQ5M2zYMHPm2LFj5kxZWZk5I0k5OTnmzJo1a8yZt99+25y55ZZbzBlJ2rp1qznz3//93+ZMaWmpOePnGk9NTTVnJKmiosKciYmJMWeuu+46c8bPEGE/X7N+paSkmDOVlZXmzNy5c80ZSSosLDRnqqqqTOurq6ubtY57QAAAJyggAIATpgLKzs7W9ddfr9jYWCUmJmrq1KnKy8trsqampkZZWVnq2bOnunfvrmnTpqmkpKRFNw0AaP9MBZSbm6usrCxt3bpV7777rurq6jRx4sQmP7985JFHtGbNGr3xxhvKzc1VYWGh7r777hbfOACgfTM9CGHdunVN3l6+fLkSExO1c+dOjRs3TqFQSP/1X/+lFStWNP4S+MUXX9QVV1yhrVu36oYbbmi5nQMA2rVv9TugUCgkSYqPj5ck7dy5U3V1dcrMzGxcM2TIEKWnp2vLli3n/TvC4bDKy8ub3AAAHZ/vAmpoaNDDDz+sG2+8UUOHDpV09rXQo6KivvaQx6SkpAu+Tnp2draCwWDjLS0tze+WAADtiO8CysrK0r59+/Taa699qw3Mnz9foVCo8ebneSwAgPbH1xNR586dq7Vr12rjxo3q06dP4/uTk5NVW1ursrKyJveCSkpKlJycfN6/KxAImJ5wCgDoGEz3gDzP09y5c/Xmm29qw4YNysjIaPLxkSNHqkuXLlq/fn3j+/Ly8nT06FGNGTOmZXYMAOgQTPeAsrKytGLFCq1evVqxsbGNv9cJBoOKiYlRMBjU/fffr3nz5ik+Pl5xcXF66KGHNGbMGB4BBwBowlRAS5culSSNHz++yftffPFFzZw5U5K0ePFiderUSdOmTVM4HNakSZP0/PPPt8hmAQAdR4TneZ7rTXxZeXm5gsGgnn32WdNwQz9DF//617+aM5K/IaFHjx41Z44fP27O/PSnPzVn/OxN8jfM9a233jJnbr31VnPGz+BOSRowYIA589UfRTfHl39M3Vx+BneePn3anJGkhx56yJx5+umnzZmsrCxz5sknnzRn/Az7lKQzZ86YM34eSOXnurvQU1suZuDAgebMwYMHTevD4bCef/55hUIhxcXFXXAds+AAAE5QQAAAJyggAIATFBAAwAkKCADgBAUEAHCCAgIAOEEBAQCcoIAAAE5QQAAAJyggAIATFBAAwAkKCADgRJudhr1s2TLTNOzt27ebj5WQkGDOSNLu3bvNmREjRpgzRUVF5sz3vvc9c2b//v3mjCR17mx/Qd38/Hxz5tSpU+bMCy+8YM5I0iuvvGLOfP755+bMNddcY84cPnzYnPnyKxZb1NXVmTN+/p0sX+PnrF271pwZO3asOSNJoVDInPHz2meHDh0yZ6Kjo80ZSaqtrTVnLrvsMtP66upq/eIXv2AaNgCgbaKAAABOUEAAACcoIACAExQQAMAJCggA4AQFBABwggICADhBAQEAnKCAAABOUEAAACcoIACAE/ZpkpdIWVmZampqmr3ezzDSBQsWmDOS5Gd+65AhQ8yZXbt2mTNpaWnmzLZt28wZSZo+fbqvnNUVV1xhzkyePNnXsf74xz+aM7NmzTJnxowZY874ue5OnDhhzkjS8uXLzZnHH3/cnOnRo4c5c//995szmzdvNmck6YEHHjBncnJyzJmePXuaM//xH/9hzkjS3//935szXbp0Ma2PjIxs1jruAQEAnKCAAABOUEAAACcoIACAExQQAMAJCggA4AQFBABwggICADhBAQEAnKCAAABOUEAAACcoIACAExGenwmHrai8vFzBYFCzZ89WIBBodq5Pnz7mY/kZAChJGRkZ5oyfAYXl5eXmTEpKijljGfr6Zbfeeqs588ILL5gzVVVV5swtt9xizkhSdXX1Jcls2LDBnJkzZ445Ex0dbc5I0po1a8yZbt26mTN9+/Y1Z44fP27OWL6XfNmgQYPMmcLCQnMmJibGnPHz/UGyDxaV7N/zqqqq9NOf/lShUEhxcXEXXMc9IACAExQQAMAJCggA4AQFBABwggICADhBAQEAnKCAAABOUEAAACcoIACAExQQAMAJCggA4AQFBABworPrDVxIYmKiaZCin6GLeXl55owk7dq1y5wZO3asOeNn6OIVV1xhzpSWlpozkrR9+3ZzpqKiwpzp3bu3OTNkyBBzRvI3WPR///d/zZnJkyebM1u2bDFnTp8+bc5I/oalLl682Jypr6+/JJl9+/aZM5K/6+jtt982Z/wMPU1KSjJnJH/fV4YOHerrWBfDPSAAgBMUEADACVMBZWdn6/rrr1dsbKwSExM1derUr/0Ya/z48YqIiGhymz17dotuGgDQ/pkKKDc3V1lZWdq6daveffdd1dXVaeLEiaqsrGyy7sEHH1RRUVHjbdGiRS26aQBA+2d6EMK6deuavL18+XIlJiZq586dGjduXOP7u3btquTk5JbZIQCgQ/pWvwMKhUKSpPj4+Cbv/9Of/qSEhAQNHTpU8+fP/8aXVA6HwyovL29yAwB0fL4fht3Q0KCHH35YN954Y5OH6P3kJz9R3759lZqaqj179uixxx5TXl6eVq5ced6/Jzs7W0899ZTfbQAA2infBZSVlaV9+/Zp06ZNTd4/a9asxj8PGzZMKSkpmjBhgg4dOqT+/ft/7e+ZP3++5s2b1/h2eXm50tLS/G4LANBO+CqguXPnau3atdq4caP69OnzjWtHjx4tScrPzz9vAQUCAQUCAT/bAAC0Y6YC8jxPDz30kN58803l5OQoIyPjopndu3dLklJSUnxtEADQMZkKKCsrSytWrNDq1asVGxur4uJiSVIwGFRMTIwOHTqkFStW6LbbblPPnj21Z88ePfLIIxo3bpyGDx/eKp8AAKB9MhXQ0qVLJZ19sumXvfjii5o5c6aioqL03nvv6bnnnlNlZaXS0tI0bdo0/frXv26xDQMAOgbzj+C+SVpamnJzc7/VhgAA3w1tdhp2dHS0acJ1t27dzMdoaGgwZyQpNTXVnDly5Ig5ExkZac7ExMSYMzt37jRnJH/nz8/n1Lmz/TJ96623zBlJ+uKLL8yZYDBozsTFxZkz4XDYnLn88svNGcnfdPlVq1aZMwsXLjRnNm/ebM5cffXV5owkHThwwJzxM5H+9ttvN2e2bdtmzkhf/wlWc1jvWDT3WmUYKQDACQoIAOAEBQQAcIICAgA4QQEBAJyggAAATlBAAAAnKCAAgBMUEADACQoIAOAEBQQAcIICAgA40WaHkcbExJgGa37wwQfmYwwaNMickaTTp0+bM+d7NdiL+fDDD82Za665xpzxMyBU8jdA0c+09EmTJpkzR48eNWck6bPPPjNn/AyF7N27tznj5zW19u7da85IUq9evcyZi7068vksXrzYnLn++uvNmY8//tickaRbbrnFnFm9erU5c+611SxKS0vNGcnfgNX4+HjT+pqammat4x4QAMAJCggA4AQFBABwggICADhBAQEAnKCAAABOUEAAACcoIACAExQQAMAJCggA4AQFBABwos3NgvM8T1LzZwmdU1tbaz6W9RjnhMNhc6a6utqc8fM5VVZWmjN+Pp9LeSw/x6mqqjJnJH/XRF1dnTnj53rw8zn5vcb9XHvnvnYt/FwPfs5DW7/G/VwPfj8nP9dEQ0ODr2Nc7JqI8PxcNa3o+PHjSktLc70NAMC3dOzYsW8cUtvmCqihoUGFhYWKjY1VREREk4+Vl5crLS1Nx44dU1xcnKMdusd5OIvzcBbn4SzOw1lt4Tx4nqeKigqlpqaqU6cL/6anzf0IrlOnThcd6x4XF/edvsDO4TycxXk4i/NwFufhLNfnIRgMXnQND0IAADhBAQEAnGhXBRQIBLRw4UIFAgHXW3GK83AW5+EszsNZnIez2tN5aHMPQgAAfDe0q3tAAICOgwICADhBAQEAnKCAAABOtJsCWrJkiS6//HJFR0dr9OjR+vDDD11v6ZJ78sknFRER0eQ2ZMgQ19tqdRs3btQdd9yh1NRURUREaNWqVU0+7nmeFixYoJSUFMXExCgzM1MHDx50s9lWdLHzMHPmzK9dH5MnT3az2VaSnZ2t66+/XrGxsUpMTNTUqVOVl5fXZE1NTY2ysrLUs2dPde/eXdOmTVNJSYmjHbeO5pyH8ePHf+16mD17tqMdn1+7KKDXX39d8+bN08KFC7Vr1y6NGDFCkyZN0okTJ1xv7ZK76qqrVFRU1HjbtGmT6y21usrKSo0YMUJLliw578cXLVqk3/72t1q2bJm2bdumbt26adKkSb4HcbZVFzsPkjR58uQm18err756CXfY+nJzc5WVlaWtW7fq3XffVV1dnSZOnNhkaOgjjzyiNWvW6I033lBubq4KCwt19913O9x1y2vOeZCkBx98sMn1sGjRIkc7vgCvHRg1apSXlZXV+HZ9fb2XmprqZWdnO9zVpbdw4UJvxIgRrrfhlCTvzTffbHy7oaHBS05O9n7zm980vq+srMwLBALeq6++6mCHl8ZXz4Pned6MGTO8O++808l+XDlx4oQnycvNzfU87+y/fZcuXbw33nijcc3+/fs9Sd6WLVtcbbPVffU8eJ7n3Xzzzd4//MM/uNtUM7T5e0C1tbXauXOnMjMzG9/XqVMnZWZmasuWLQ535sbBgweVmpqqfv366d5779XRo0ddb8mpgoICFRcXN7k+gsGgRo8e/Z28PnJycpSYmKjBgwdrzpw5Ki0tdb2lVhUKhSRJ8fHxkqSdO3eqrq6uyfUwZMgQpaend+jr4avn4Zw//elPSkhI0NChQzV//nzfL1PSWtrcMNKvOnXqlOrr65WUlNTk/UlJSfrkk08c7cqN0aNHa/ny5Ro8eLCKior01FNPaezYsdq3b59iY2Ndb8+J4uJiSTrv9XHuY98VkydP1t13362MjAwdOnRIjz/+uKZMmaItW7YoMjLS9fZaXENDgx5++GHdeOONGjp0qKSz10NUVJR69OjRZG1Hvh7Odx4k6Sc/+Yn69u2r1NRU7dmzR4899pjy8vK0cuVKh7ttqs0XEP6/KVOmNP55+PDhGj16tPr27as///nPuv/++x3uDG3BPffc0/jnYcOGafjw4erfv79ycnI0YcIEhztrHVlZWdq3b9934veg3+RC52HWrFmNfx42bJhSUlI0YcIEHTp0SP3797/U2zyvNv8juISEBEVGRn7tUSwlJSVKTk52tKu2oUePHho0aJDy8/Ndb8WZc9cA18fX9evXTwkJCR3y+pg7d67Wrl2r999/v8nLtyQnJ6u2tlZlZWVN1nfU6+FC5+F8Ro8eLUlt6npo8wUUFRWlkSNHav369Y3va2ho0Pr16zVmzBiHO3PvzJkzOnTokFJSUlxvxZmMjAwlJyc3uT7Ky8u1bdu27/z1cfz4cZWWlnao68PzPM2dO1dvvvmmNmzYoIyMjCYfHzlypLp06dLkesjLy9PRo0c71PVwsfNwPrt375aktnU9uH4URHO89tprXiAQ8JYvX+59/PHH3qxZs7wePXp4xcXFrrd2Sf3iF7/wcnJyvIKCAu+vf/2rl5mZ6SUkJHgnTpxwvbVWVVFR4X300UfeRx995Enynn32We+jjz7yPv30U8/zPO/f/u3fvB49enirV6/29uzZ4915551eRkaGV11d7XjnLeubzkNFRYX3y1/+0tuyZYtXUFDgvffee961117rDRw40KupqXG99RYzZ84cLxgMejk5OV5RUVHjraqqqnHN7NmzvfT0dG/Dhg3ejh07vDFjxnhjxoxxuOuWd7HzkJ+f7z399NPejh07vIKCAm/16tVev379vHHjxjneeVPtooA8z/N+97vfeenp6V5UVJQ3atQob+vWra63dMlNnz7dS0lJ8aKiorzevXt706dP9/Lz811vq9W9//77nqSv3WbMmOF53tmHYj/xxBNeUlKSFwgEvAkTJnh5eXluN90Kvuk8VFVVeRMnTvR69erldenSxevbt6/34IMPdrj/pJ3v85fkvfjii41rqqurvZ///OfeZZdd5nXt2tW76667vKKiInebbgUXOw9Hjx71xo0b58XHx3uBQMAbMGCA94//+I9eKBRyu/Gv4OUYAABOtPnfAQEAOiYKCADgBAUEAHCCAgIAOEEBAQCcoIAAAE5QQAAAJyggAIATFBAAwAkKCADgBAUEAHCCAgIAOPH/APsGHzIuldafAAAAAElFTkSuQmCC\n"
          },
          "metadata": {}
        }
      ],
      "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",
        "감별자는 합성곱 신경망(Convolutional Neural Network, CNN) 기반의 이미지 분류기입니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "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": [
        "(아직까지 훈련이 되지 않은) 감별자를 사용하여, 생성된 이미지가 진짜인지 가짜인지 판별합니다. 모델은 진짜 이미지에는 양수의 값 (positive values)을, 가짜 이미지에는 음수의 값 (negative values)을 출력하도록 훈련되어집니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "gDkA05NE6QMs",
        "outputId": "01b37f45-7eda-4328-cbcf-7e1fcd0cc935",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-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"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor([[-0.00040435]], 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": {
        "id": "psQfmXxYKU3X"
      },
      "outputs": [],
      "source": [
        "# 이 메서드는 크로스 엔트로피 손실함수 (cross entropy loss)를 계산하기 위해 헬퍼 (helper) 함수를 반환합니다.\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": {
        "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": {
        "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": {
        "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": {
        "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": {
        "id": "NS2GWywBbAWo"
      },
      "outputs": [],
      "source": [
        "EPOCHS = 50\n",
        "noise_dim = 100\n",
        "num_examples_to_generate = 16\n",
        "\n",
        "# 이 시드를 시간이 지나도 재활용하겠습니다.\n",
        "# (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": {
        "id": "3t5ibNo05jCB"
      },
      "outputs": [],
      "source": [
        "# `tf.function`이 어떻게 사용되는지 주목해 주세요.\n",
        "# 이 데코레이터는 함수를 \"컴파일\"합니다.\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": {
        "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",
        "    # GIF를 위한 이미지를 바로 생성합니다.\n",
        "    display.clear_output(wait=True)\n",
        "    generate_and_save_images(generator,\n",
        "                             epoch + 1,\n",
        "                             seed)\n",
        "\n",
        "    # 15 에포크가 지날 때마다 모델을 저장합니다.\n",
        "    if (epoch + 1) % 15 == 0:\n",
        "      checkpoint.save(file_prefix = checkpoint_prefix)\n",
        "\n",
        "    # print (' 에포크 {} 에서 걸린 시간은 {} 초 입니다'.format(epoch +1, time.time()-start))\n",
        "    print ('Time for epoch {} is {} sec'.format(epoch + 1, time.time()-start))\n",
        "\n",
        "  # 마지막 에포크가 끝난 후 생성합니다.\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": {
        "id": "RmdVsmvhPxyy"
      },
      "outputs": [],
      "source": [
        "def generate_and_save_images(model, epoch, test_input):\n",
        "  # `training`이 False로 맞춰진 것을 주목하세요.\n",
        "  # 이렇게 하면 (배치정규화를 포함하여) 모든 층들이 추론 모드로 실행됩니다.\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()` 메서드를 호출하여 생성자와 판별자를 동시에 훈련합니다. GAN 훈련은 까다로울 수 있습니다. 생성자와 판별자가 서로를 압도하지 않는 것이 중요합니다(예: 비슷한 속도로 훈련됨).\n",
        "\n",
        "훈련 초기에 생성된 이미지는 무작위 노이즈처럼 보입니다. 훈련이 진행됨에 따라 생성된 숫자는 점점 더 실제처럼 보일 것입니다. 약 50 epoch 후에는 MNIST 숫자와 유사합니다. Colab의 기본 설정에서 이 작업은 epoch당 약 1분 정도 소요될 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Ly3UN0SLLY2l",
        "outputId": "72ca9eca-8ac6-416f-b84b-b932917fa5d0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 364
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 400x400 with 16 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Time for epoch 4 is 11.782860040664673 sec\n"
          ]
        }
      ],
      "source": [
        "train(train_dataset, EPOCHS)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rfM4YcPVPkNO"
      },
      "source": [
        "마지막 체크포인트를 복구합니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XhXsd0srPo8c"
      },
      "outputs": [],
      "source": [
        "checkpoint.restore(tf.train.latest_checkpoint(checkpoint_dir))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P4M_vIbUi7c0"
      },
      "source": [
        "## GIF 생성\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "WfO5wCdclHGL"
      },
      "outputs": [],
      "source": [
        "# 에포크 숫자를 사용하여 하나의 이미지를 보여줍니다.\n",
        "def display_image(epoch_no):\n",
        "  return PIL.Image.open('image_at_epoch_{:04d}.png'.format(epoch_no))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5x3q9_Oe5q0A"
      },
      "outputs": [],
      "source": [
        "display_image(EPOCHS)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NywiH3nL8guF"
      },
      "source": [
        "`imageio`로 훈련 중에 저장된 이미지를 사용해 GIF 애니메이션을 만듭니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IGKQgENQ8lEI"
      },
      "outputs": [],
      "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",
      "source": [
        "!pip install git+https://github.com/tensorflow/docs"
      ],
      "metadata": {
        "id": "Hhk27RVFn9C1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZBwyU6t2Wf3g"
      },
      "outputs": [],
      "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) 대규모 유명인 얼굴 특성(CelebA) 데이터세트와 같은 다른 데이터세트를 실험해볼 수 있습니다. GAN에 대해 자세히 알아보려면 [NIPS 2016 튜토리얼: 생성적 적대 네트워크](https://arxiv.org/abs/1701.00160)를 참조하세요.\n"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "dcgan.ipynb",
      "provenance": [],
      "gpuType": "T4",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}