Chapter_7_SGAN(edited).ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/zergswim/GAN/blob/main/Chapter_7_SGAN(edited).ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Sgta16A7CUCW"
      },
      "source": [
        "# 7장: SGAN"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wGWR9bzYCUCa"
      },
      "source": [
        "<table align=\"left\">\n",
        "  <td>\n",
        "    <a target=\"_blank\" href=\"https://colab.research.google.com/github/rickiepark/gans-in-action/blob/master/chapter-7/Chapter_7_SGAN.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" />구글 코랩에서 실행하기</a>\n",
        "  </td>\n",
        "</table>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "fMfOE4pUCUCb"
      },
      "outputs": [],
      "source": [
        "%matplotlib inline\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "from tensorflow.keras import backend as K\n",
        "\n",
        "from tensorflow.keras.datasets import mnist\n",
        "from tensorflow.keras.layers import (Activation, BatchNormalization, Concatenate, Dense,\n",
        "                                     Dropout, Flatten, Input, Lambda, Reshape)\n",
        "from tensorflow.keras.layers import LeakyReLU\n",
        "from tensorflow.keras.layers import Conv2D, Conv2DTranspose\n",
        "from tensorflow.keras.models import Model, Sequential\n",
        "from tensorflow.keras.optimizers import Adam\n",
        "from tensorflow.keras.utils import to_categorical"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_4FgnWooCUCb"
      },
      "source": [
        "## 데이터셋"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "rOmpG7_ZCUCb"
      },
      "outputs": [],
      "source": [
        "class Dataset:\n",
        "    def __init__(self, num_labeled):\n",
        "\n",
        "        # 훈련에 사용할 레이블된 샘플 개수\n",
        "        self.num_labeled = num_labeled\n",
        "\n",
        "        # MNIST 데이터셋 적재\n",
        "        (self.x_train, self.y_train), (self.x_test,\n",
        "                                       self.y_test) = mnist.load_data()\n",
        "\n",
        "        def preprocess_imgs(x):\n",
        "            # [0, 255] 사이 흑백 픽셀 값을 [–1, 1] 사이로 변환\n",
        "            x = (x.astype(np.float32) - 127.5) / 127.5\n",
        "            # 너비 × 높이 × 채널로 이미지 차원을 확장\n",
        "            x = np.expand_dims(x, axis=3)\n",
        "            return x\n",
        "\n",
        "        def preprocess_labels(y):\n",
        "            return y.reshape(-1, 1)\n",
        "\n",
        "        # 훈련 데이터\n",
        "        self.x_train = preprocess_imgs(self.x_train)\n",
        "        self.y_train = preprocess_labels(self.y_train)\n",
        "\n",
        "        # 테스트 데이터\n",
        "        self.x_test = preprocess_imgs(self.x_test)\n",
        "        self.y_test = preprocess_labels(self.y_test)\n",
        "\n",
        "    def batch_labeled(self, batch_size):\n",
        "        # 레이블된 이미지와 레이블의 랜덤 배치 만들기\n",
        "        idx = np.random.randint(0, self.num_labeled, batch_size)\n",
        "        imgs = self.x_train[idx]\n",
        "        labels = self.y_train[idx]\n",
        "        return imgs, labels\n",
        "\n",
        "    def batch_unlabeled(self, batch_size):\n",
        "        # 레이블이 없는 이미지의 랜덤 배치 만들기\n",
        "        idx = np.random.randint(self.num_labeled, self.x_train.shape[0],\n",
        "                                batch_size)\n",
        "        imgs = self.x_train[idx]\n",
        "        return imgs\n",
        "\n",
        "    def training_set(self):\n",
        "        x_train = self.x_train[range(self.num_labeled)]\n",
        "        y_train = self.y_train[range(self.num_labeled)]\n",
        "        return x_train, y_train\n",
        "\n",
        "    def test_set(self):\n",
        "        return self.x_test, self.y_test"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "BcElbU6SCUCc"
      },
      "outputs": [],
      "source": [
        "# 사용할 레이블된 샘플 개수 (나머지는 레이블없이 사용합니다)\n",
        "num_labeled = 100\n",
        "\n",
        "dataset = Dataset(num_labeled)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O9UQJrdTCUCc"
      },
      "source": [
        "# SGAN"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "TTpjfRu3CUCc"
      },
      "outputs": [],
      "source": [
        "img_rows = 28\n",
        "img_cols = 28\n",
        "channels = 1\n",
        "\n",
        "# 입력 이미지 차원\n",
        "img_shape = (img_rows, img_cols, channels)\n",
        "\n",
        "# 생성자의 입력으로 사용할 잡음 벡터의 크기\n",
        "z_dim = 100\n",
        "\n",
        "# 데이터셋에 있는 클래스 개수\n",
        "num_classes = 10"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pIst7kenCUCc"
      },
      "source": [
        "## 생성자"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "4WzMJ065CUCd"
      },
      "outputs": [],
      "source": [
        "def build_generator(z_dim):\n",
        "\n",
        "    model = Sequential()\n",
        "\n",
        "    # 완전 연결 층을 사용해 입력을 7 × 7 × 256 크기 텐서로 바꿉니다.\n",
        "    model.add(Dense(256 * 7 * 7, input_dim=z_dim))\n",
        "    model.add(Reshape((7, 7, 256)))\n",
        "\n",
        "    # 7 × 7 × 256에서 14 × 14 × 128 텐서로 바꾸는 전치 합성곱 층\n",
        "    model.add(Conv2DTranspose(128, kernel_size=3, strides=2, padding='same'))\n",
        "\n",
        "    # 배치 정규화\n",
        "    model.add(BatchNormalization())\n",
        "\n",
        "    # LeakyReLU 활성화 함수\n",
        "    model.add(LeakyReLU(alpha=0.01))\n",
        "\n",
        "    # 14 × 14 × 128에서 14 × 14 × 64 텐서로 바꾸는 전치 합성곱 층\n",
        "    model.add(Conv2DTranspose(64, kernel_size=3, strides=1, padding='same'))\n",
        "\n",
        "    # 배치 정규화\n",
        "    model.add(BatchNormalization())\n",
        "\n",
        "    # LeakyReLU 활성화 함수\n",
        "    model.add(LeakyReLU(alpha=0.01))\n",
        "\n",
        "    # 14 × 14 × 64에서 28 × 28 × 1 텐서로 바꾸는 전치 합성곱 층\n",
        "    model.add(Conv2DTranspose(1, kernel_size=3, strides=2, padding='same'))\n",
        "\n",
        "    # tanh 활성화 함수\n",
        "    model.add(Activation('tanh'))\n",
        "\n",
        "    return model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2MJeqmKHCUCd"
      },
      "source": [
        "## 판별자"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "zYpCZ5fOCUCd"
      },
      "outputs": [],
      "source": [
        "def build_discriminator_net(img_shape):\n",
        "\n",
        "    model = Sequential()\n",
        "\n",
        "    # 28 × 28 × 1에서 14 × 14 × 32 텐서로 바꾸는 합성곱 층\n",
        "    model.add(\n",
        "        Conv2D(32,\n",
        "               kernel_size=3,\n",
        "               strides=2,\n",
        "               input_shape=img_shape,\n",
        "               padding='same'))\n",
        "\n",
        "    # LeakyReLU 활성화 함수\n",
        "    model.add(LeakyReLU(alpha=0.01))\n",
        "\n",
        "    # 14 × 14 × 32에서 7 × 7 × 64 텐서로 바꾸는 합성곱 층\n",
        "    model.add(\n",
        "        Conv2D(64,\n",
        "               kernel_size=3,\n",
        "               strides=2,\n",
        "               padding='same'))\n",
        "    \n",
        "    # LeakyReLU 활성화 함수\n",
        "    model.add(LeakyReLU(alpha=0.01))\n",
        "\n",
        "    # 7 × 7 × 64에서 3 × 3 × 128 텐서로 바꾸는 합성곱 층\n",
        "    model.add(\n",
        "        Conv2D(128,\n",
        "               kernel_size=3,\n",
        "               strides=2,\n",
        "               padding='same'))\n",
        "    \n",
        "    # LeakyReLU 활성화 함수\n",
        "    model.add(LeakyReLU(alpha=0.01))\n",
        "\n",
        "    # 드롭아웃\n",
        "    model.add(Dropout(0.5))\n",
        "\n",
        "    # 텐서 펼치기\n",
        "    model.add(Flatten())\n",
        "\n",
        "    # num_classes 개의 뉴런을 가진 완전 연결 층\n",
        "    model.add(Dense(num_classes))\n",
        "\n",
        "    return model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "wcIsVDTgCUCd"
      },
      "outputs": [],
      "source": [
        "def build_discriminator_supervised(discriminator_net):\n",
        "\n",
        "    model = Sequential()\n",
        "\n",
        "    model.add(discriminator_net)\n",
        "\n",
        "    # 진짜 클래스에 대한 예측 확률을 출력하는 소프트맥스 활성화 함수\n",
        "    model.add(Activation('softmax'))\n",
        "\n",
        "    return model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "_IVe9hFvCUCd"
      },
      "outputs": [],
      "source": [
        "def build_discriminator_unsupervised(discriminator_net):\n",
        "\n",
        "    model = Sequential()\n",
        "\n",
        "    model.add(discriminator_net)\n",
        "\n",
        "    def predict(x):\n",
        "        # 진짜 클래스에 대한 확률 분포를 진짜 대 가짜의 이진 확률로 변환합니다.\n",
        "        prediction = 1.0 - (1.0 /\n",
        "                            (K.sum(K.exp(x), axis=-1, keepdims=True) + 1.0))\n",
        "        return prediction\n",
        "\n",
        "    # 앞서 정의한 진짜 대 가짜 확률을 출력하는 뉴런\n",
        "    model.add(Lambda(predict))\n",
        "\n",
        "    return model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3g1t9cHKCUCe"
      },
      "source": [
        "## 모델 구성"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "XJMkjCNNCUCe"
      },
      "outputs": [],
      "source": [
        "# def build_gan(generator, discriminator):\n",
        "\n",
        "#     model = Sequential()\n",
        "\n",
        "#     # 생성자와 판별자 모델을 연결하기\n",
        "#     model.add(generator)\n",
        "#     model.add(discriminator)\n",
        "\n",
        "#     return model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4kvzhVU0CUCe"
      },
      "source": [
        "### 판별자"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "4Vp0T0X5CUCe"
      },
      "outputs": [],
      "source": [
        "# 판별자 기반 모델: 이 층들은 지도 학습 훈련과 비지도 학습 훈련에 공유됩니다.\n",
        "discriminator_net = build_discriminator_net(img_shape)\n",
        "\n",
        "# 지도 학습 훈련을 위해 판별자를 만들고 컴파일합니다.\n",
        "discriminator_supervised = build_discriminator_supervised(discriminator_net)\n",
        "discriminator_supervised.compile(loss='categorical_crossentropy',\n",
        "                                 metrics=['accuracy'],\n",
        "                                 optimizer=Adam(learning_rate=0.0003))\n",
        "\n",
        "# 비지도 학습 훈련을 위해 판별자를 만들고 컴파일합니다.\n",
        "discriminator_unsupervised = build_discriminator_unsupervised(discriminator_net)\n",
        "discriminator_unsupervised.compile(loss='binary_crossentropy',\n",
        "                                   optimizer=Adam())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZsdB7aFkCUCe"
      },
      "source": [
        "### 생성자"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "HjyDCLHvCUCe"
      },
      "outputs": [],
      "source": [
        "# 생성자를 만듭니다.\n",
        "import tensorflow as tf\n",
        "generator = build_generator(z_dim)\n",
        "optimizer_g = tf.keras.optimizers.Adam()\n",
        "train_loss = tf.keras.metrics.Mean()\n",
        "\n",
        "@tf.function\n",
        "def train_step(z, real):\n",
        "    with tf.GradientTape() as tape:\n",
        "        gen_imgs = generator(z)\n",
        "        pred = discriminator_unsupervised(gen_imgs) # or discriminator_supervised?\n",
        "        loss = tf.keras.losses.binary_crossentropy(real, pred) #? real or fake?\n",
        "\n",
        "    gradients = tape.gradient(loss, generator.trainable_variables)\n",
        "    optimizer_g.apply_gradients(zip(gradients, generator.trainable_variables))\n",
        "\n",
        "    train_loss(loss)\n",
        "    g_loss = train_loss.result()\n",
        "    \n",
        "    return gen_imgs, g_loss\n",
        "\n",
        "# generator = build_generator(z_dim)\n",
        "\n",
        "# # 생성자 훈련을 위해 판별자의 모델 파라미터를 동결합니다.\n",
        "# discriminator_unsupervised.trainable = False\n",
        "\n",
        "# # 생성자를 훈련하기 위해 고정된 판별자로 GAN 모델을 만들고 컴파일합니다.\n",
        "# # 노트: 비지도 학습용 판별자를 사용하세요.\n",
        "# gan = build_gan(generator, discriminator_unsupervised)\n",
        "# gan.compile(loss='binary_crossentropy', optimizer=Adam())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_SkyHoMhCUCf"
      },
      "source": [
        "## 훈련"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "lOsI6htfCUCf"
      },
      "outputs": [],
      "source": [
        "supervised_losses = []\n",
        "iteration_checkpoints = []\n",
        "\n",
        "\n",
        "def train(iterations, batch_size, sample_interval):\n",
        "\n",
        "    # 진짜 이미지의 레이블: 모두 1\n",
        "    real = np.ones((batch_size, 1))\n",
        "\n",
        "    # 가짜 이미지의 레이블: 모두 0\n",
        "    fake = np.zeros((batch_size, 1))\n",
        "\n",
        "    for iteration in range(iterations):\n",
        "\n",
        "        # -------------------------\n",
        "        #  판별자 훈련\n",
        "        # -------------------------\n",
        "\n",
        "        # 레이블된 샘플을 가져옵니다.\n",
        "        imgs, labels = dataset.batch_labeled(batch_size)\n",
        "\n",
        "        # 레이블을 원-핫 인코딩합니다.\n",
        "        labels = to_categorical(labels, num_classes=num_classes)\n",
        "\n",
        "        # 레이블이 없는 샘플을 가져옵니다.\n",
        "        imgs_unlabeled = dataset.batch_unlabeled(batch_size)\n",
        "\n",
        "        # 가짜 이미지의 배치를 생성합니다.\n",
        "        z = np.random.normal(0, 1, (batch_size, z_dim))\n",
        "        # gen_imgs = generator.predict(z)\n",
        "        gen_imgs, g_loss = train_step(z, real)\n",
        "\n",
        "        # 레이블된 진짜 샘플에서 훈련합니다.\n",
        "        d_loss_supervised, accuracy = discriminator_supervised.train_on_batch(imgs, labels)\n",
        "\n",
        "        # 레이블이 없는 진짜 샘플에서 훈련합니다.\n",
        "        d_loss_real = discriminator_unsupervised.train_on_batch(imgs_unlabeled, real)\n",
        "\n",
        "        # 가짜 샘플에서 훈련합니다.\n",
        "        d_loss_fake = discriminator_unsupervised.train_on_batch(gen_imgs, fake)\n",
        "\n",
        "        d_loss_unsupervised = 0.5 * np.add(d_loss_real, d_loss_fake)\n",
        "\n",
        "        # ---------------------\n",
        "        #  생성자 훈련\u001e\n",
        "        # ---------------------\n",
        "\n",
        "        # 가짜 이미지의 배치를 생성합니다.\n",
        "        # z = np.random.normal(0, 1, (batch_size, z_dim))\n",
        "        # gen_imgs = generator.predict(z)\n",
        "\n",
        "        # 생성자를 훈련합니다.\n",
        "        # g_loss = gan.train_on_batch(z, np.ones((batch_size, 1)))\n",
        "\n",
        "        if (iteration + 1) % sample_interval == 0:\n",
        "\n",
        "            # 훈련이 끝난 후 그래프를 그리기 위해 판별자의 지도 학습 분류 손실을 기록합니다.\n",
        "            supervised_losses.append(d_loss_supervised)\n",
        "            iteration_checkpoints.append(iteration + 1)\n",
        "\n",
        "            # 훈련 과정을 출력합니다.\n",
        "            print(\n",
        "                \"%d [D loss supervised: %.4f, acc.: %.2f%%] [D loss unsupervised: %.4f] [G loss: %f]\"\n",
        "                % (iteration + 1, d_loss_supervised, 100 * accuracy,\n",
        "                   d_loss_unsupervised, g_loss))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fy5892ZuCUCf"
      },
      "source": [
        "## 모델 훈련과 출력 조사"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9J7305B3CUCf",
        "outputId": "e4a85ef0-ab8b-4a87-ba82-55874529cc26",
        "scrolled": true
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "800 [D loss supervised: 0.3342, acc.: 93.75%] [D loss unsupervised: 0.0103] [G loss: 6.172999]\n",
            "1600 [D loss supervised: 0.1188, acc.: 96.88%] [D loss unsupervised: 0.0892] [G loss: 8.065452]\n",
            "2400 [D loss supervised: 0.0290, acc.: 100.00%] [D loss unsupervised: 0.2991] [G loss: 6.885077]\n",
            "3200 [D loss supervised: 0.0112, acc.: 100.00%] [D loss unsupervised: 0.3382] [G loss: 5.904358]\n",
            "4000 [D loss supervised: 0.0039, acc.: 100.00%] [D loss unsupervised: 0.3219] [G loss: 5.269551]\n",
            "4800 [D loss supervised: 0.0041, acc.: 100.00%] [D loss unsupervised: 0.4613] [G loss: 4.803010]\n",
            "5600 [D loss supervised: 0.0024, acc.: 100.00%] [D loss unsupervised: 0.5282] [G loss: 4.463067]\n",
            "6400 [D loss supervised: 0.0013, acc.: 100.00%] [D loss unsupervised: 0.4419] [G loss: 4.175329]\n",
            "7200 [D loss supervised: 0.0030, acc.: 100.00%] [D loss unsupervised: 0.4042] [G loss: 3.931105]\n",
            "8000 [D loss supervised: 0.0093, acc.: 100.00%] [D loss unsupervised: 0.5650] [G loss: 3.731243]\n"
          ]
        }
      ],
      "source": [
        "# 하이퍼파라미터를 셋팅합니다.\n",
        "iterations = 8000\n",
        "batch_size = 32\n",
        "sample_interval = 800\n",
        "\n",
        "# 지정한 반복 횟수 동안 SGAN을 훈련합니다.\n",
        "train(iterations, batch_size, sample_interval)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "h92u9tEzCUCg",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 365
        },
        "outputId": "1a843bf7-43c7-4795-db86-4842105e065f"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1080x360 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "losses = np.array(supervised_losses)\n",
        "\n",
        "# 판별자의 지도 학습 손실을 그립니다.\n",
        "plt.figure(figsize=(15, 5))\n",
        "plt.plot(iteration_checkpoints, losses, label=\"Discriminator loss\")\n",
        "\n",
        "plt.xticks(iteration_checkpoints, rotation=90)\n",
        "\n",
        "plt.title(\"Discriminator – Supervised Loss\")\n",
        "plt.xlabel(\"Iteration\")\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.legend()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b5zD1QwrCUCh"
      },
      "source": [
        "## SGAN 분류기 – 훈련 세트와 테스트 세트 정확도"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "ajShPxUjCUCh",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c8c43a83-253d-4f31-92c1-9229e46696ca"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4/4 [==============================] - 0s 14ms/step - loss: 0.0030 - accuracy: 1.0000\n",
            "Training Accuracy: 100.00%\n"
          ]
        }
      ],
      "source": [
        "x, y = dataset.training_set()\n",
        "y = to_categorical(y, num_classes=num_classes)\n",
        "\n",
        "# 훈련 세트에서 분류 정확도 계산\n",
        "_, accuracy = discriminator_supervised.evaluate(x, y)\n",
        "print(\"Training Accuracy: %.2f%%\" % (100 * accuracy))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "sVJlwLDdCUCh",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d3792cc4-43de-4dc2-9d46-3096659881ec"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "313/313 [==============================] - 1s 3ms/step - loss: 0.2723 - accuracy: 0.9063\n",
            "Test Accuracy: 90.63%\n"
          ]
        }
      ],
      "source": [
        "x, y = dataset.test_set()\n",
        "y = to_categorical(y, num_classes=num_classes)\n",
        "\n",
        "# 테스트 세트에서 분류 정확도 계산\n",
        "_, accuracy = discriminator_supervised.evaluate(x, y)\n",
        "print(\"Test Accuracy: %.2f%%\" % (100 * accuracy))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FZ2uciaRCUCh"
      },
      "source": [
        "# 완전히 지도 학습으로 훈련된 분류기"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "id": "Uf-efoiDCUCi"
      },
      "outputs": [],
      "source": [
        "# SGAN 판별자와 같은 네트워크 구조를 가진 지도 학습 분류기\n",
        "mnist_classifier = build_discriminator_supervised(build_discriminator_net(img_shape))\n",
        "mnist_classifier.compile(loss='categorical_crossentropy',\n",
        "                         metrics=['accuracy'],\n",
        "                         optimizer=Adam())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "_V-rV4SqCUCi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5430cc89-967b-40e8-c649-7f09f35375ed"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/30\n",
            "4/4 [==============================] - 0s 22ms/step - loss: 2.3004 - accuracy: 0.1600\n",
            "Epoch 2/30\n",
            "4/4 [==============================] - 0s 6ms/step - loss: 2.2109 - accuracy: 0.2800\n",
            "Epoch 3/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 2.0941 - accuracy: 0.4600\n",
            "Epoch 4/30\n",
            "4/4 [==============================] - 0s 6ms/step - loss: 1.9827 - accuracy: 0.5400\n",
            "Epoch 5/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 1.8261 - accuracy: 0.4500\n",
            "Epoch 6/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 1.6640 - accuracy: 0.4800\n",
            "Epoch 7/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 1.4310 - accuracy: 0.5200\n",
            "Epoch 8/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 1.1255 - accuracy: 0.7200\n",
            "Epoch 9/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.8863 - accuracy: 0.7700\n",
            "Epoch 10/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.6339 - accuracy: 0.8300\n",
            "Epoch 11/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.5623 - accuracy: 0.8300\n",
            "Epoch 12/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.3921 - accuracy: 0.8900\n",
            "Epoch 13/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.3992 - accuracy: 0.8700\n",
            "Epoch 14/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.3016 - accuracy: 0.8900\n",
            "Epoch 15/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.2470 - accuracy: 0.9200\n",
            "Epoch 16/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.1929 - accuracy: 0.9500\n",
            "Epoch 17/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.1623 - accuracy: 0.9600\n",
            "Epoch 18/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.1622 - accuracy: 0.9500\n",
            "Epoch 19/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.1393 - accuracy: 0.9700\n",
            "Epoch 20/30\n",
            "4/4 [==============================] - 0s 7ms/step - loss: 0.0886 - accuracy: 1.0000\n",
            "Epoch 21/30\n",
            "4/4 [==============================] - 0s 6ms/step - loss: 0.0431 - accuracy: 1.0000\n",
            "Epoch 22/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.0682 - accuracy: 0.9800\n",
            "Epoch 23/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.0624 - accuracy: 0.9900\n",
            "Epoch 24/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.0670 - accuracy: 0.9800\n",
            "Epoch 25/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.0464 - accuracy: 0.9800\n",
            "Epoch 26/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.0291 - accuracy: 1.0000\n",
            "Epoch 27/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.0527 - accuracy: 0.9900\n",
            "Epoch 28/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.0502 - accuracy: 0.9800\n",
            "Epoch 29/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.0470 - accuracy: 0.9900\n",
            "Epoch 30/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.0504 - accuracy: 0.9800\n"
          ]
        }
      ],
      "source": [
        "imgs, labels = dataset.training_set()\n",
        "\n",
        "# 레이블을 원-핫 인코딩합니다.\n",
        "labels = to_categorical(labels, num_classes=num_classes)\n",
        "\n",
        "# 분류기를 훈련합니다.\n",
        "training = mnist_classifier.fit(x=imgs,\n",
        "                                y=labels,\n",
        "                                batch_size=32,\n",
        "                                epochs=30,\n",
        "                                verbose=1)\n",
        "losses = training.history['loss']\n",
        "accuracies = training.history['accuracy']"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "NCLm27uFCUCi",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 336
        },
        "outputId": "241a37d5-df72-43ce-ea31-a1ec46f4b0ac"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x360 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# 분류 손실을 그립니다\n",
        "plt.figure(figsize=(10, 5))\n",
        "plt.plot(np.array(losses), label=\"Loss\")\n",
        "plt.title(\"Classification Loss\")\n",
        "plt.legend()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "id": "bdmZTbHnCUCi",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 336
        },
        "outputId": "78297a4e-fbbe-477a-8120-ffcc28e9b856"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x360 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# 분류 정확도를 그립니다.\n",
        "plt.figure(figsize=(10, 5))\n",
        "plt.plot(np.array(accuracies), label=\"Accuracy\")\n",
        "plt.title(\"Classification Accuracy\")\n",
        "plt.legend()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "UAevicZSCUCi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0b879a1c-de90-45b2-dd58-9b00deda96a2"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4/4 [==============================] - 0s 4ms/step - loss: 0.0270 - accuracy: 1.0000\n",
            "Training Accuracy: 100.00%\n"
          ]
        }
      ],
      "source": [
        "x, y = dataset.training_set()\n",
        "y = to_categorical(y, num_classes=num_classes)\n",
        "\n",
        "# 훈련 세트에 대한 분류 정확도를 계산합니다.\n",
        "_, accuracy = mnist_classifier.evaluate(x, y)\n",
        "print(\"Training Accuracy: %.2f%%\" % (100 * accuracy))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "id": "o02hr24eCUCi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5925d8a3-aee9-41ce-8a73-233043f198e8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "313/313 [==============================] - 1s 3ms/step - loss: 1.3747 - accuracy: 0.7112\n",
            "Test Accuracy: 71.12%\n"
          ]
        }
      ],
      "source": [
        "x, y = dataset.test_set()\n",
        "y = to_categorical(y, num_classes=num_classes)\n",
        "\n",
        "# 테스트 세트에 대한 분류 정확도를 계산합니다.\n",
        "_, accuracy = mnist_classifier.evaluate(x, y)\n",
        "print(\"Test Accuracy: %.2f%%\" % (100 * accuracy))"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "Chapter_7_SGAN(edited)",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "TensorFlow 2.3 on Python 3.6 (CUDA 10.1)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.7"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}