Chapter_7_SGAN(edited_exp).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_exp).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": [
        "num_labeled = 100\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",
        "img_shape = (img_rows, img_cols, channels)\n",
        "z_dim = 100\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",
        "    model = Sequential()\n",
        "    model.add(Dense(256 * 7 * 7, input_dim=z_dim))\n",
        "    model.add(Reshape((7, 7, 256)))\n",
        "    model.add(Conv2DTranspose(128, kernel_size=3, strides=2, padding='same'))\n",
        "    model.add(BatchNormalization())\n",
        "    model.add(LeakyReLU(alpha=0.01))\n",
        "    model.add(Conv2DTranspose(64, kernel_size=3, strides=1, padding='same'))\n",
        "    model.add(BatchNormalization())\n",
        "    model.add(LeakyReLU(alpha=0.01))\n",
        "    model.add(Conv2DTranspose(1, kernel_size=3, strides=2, padding='same'))\n",
        "    model.add(Activation('tanh'))\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",
        "    model = Sequential()\n",
        "    model.add( Conv2D(32, kernel_size=3, strides=2, input_shape=img_shape, padding='same'))\n",
        "    model.add(LeakyReLU(alpha=0.01))\n",
        "    model.add( Conv2D(64, kernel_size=3, strides=2, padding='same'))\n",
        "    model.add(LeakyReLU(alpha=0.01))\n",
        "    model.add( Conv2D(128, kernel_size=3, strides=2, padding='same'))\n",
        "    model.add(LeakyReLU(alpha=0.01))\n",
        "    model.add(Dropout(0.5))\n",
        "    model.add(Flatten())\n",
        "    # model.add(Dense(num_classes))\n",
        "    return model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "wcIsVDTgCUCd"
      },
      "outputs": [],
      "source": [
        "def build_discriminator_supervised(discriminator_net):\n",
        "    model = Sequential()\n",
        "    model.add(discriminator_net)\n",
        "    model.add(Dense(num_classes))\n",
        "    model.add(Activation('softmax'))\n",
        "    return model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "_IVe9hFvCUCd"
      },
      "outputs": [],
      "source": [
        "def build_discriminator_unsupervised(discriminator_net):\n",
        "    model = Sequential()\n",
        "    model.add(discriminator_net)\n",
        "\n",
        "    # model.add(Dense(1, activation='sigmoid'))\n",
        "\n",
        "    model.add(Dense(num_classes))\n",
        "\n",
        "    def predict(x):\n",
        "        # 진짜 클래스에 대한 확률 분포를 진짜 대 가짜의 이진 확률로 변환합니다.\n",
        "        prediction = 1.0 - (1.0 / (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",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6bf39100-ec20-48fe-bd99-2e57392b7a33"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_1\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " sequential (Sequential)     (None, 2048)              92672     \n",
            "                                                                 \n",
            " dense (Dense)               (None, 10)                20490     \n",
            "                                                                 \n",
            " activation (Activation)     (None, 10)                0         \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 113,162\n",
            "Trainable params: 113,162\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n",
            "Model: \"sequential_2\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " sequential (Sequential)     (None, 2048)              92672     \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 10)                20490     \n",
            "                                                                 \n",
            " lambda (Lambda)             (None, 1)                 0         \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 113,162\n",
            "Trainable params: 113,162\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "discriminator_net = build_discriminator_net(img_shape)\n",
        "discriminator_supervised = build_discriminator_supervised(discriminator_net)\n",
        "discriminator_supervised.compile(loss='categorical_crossentropy', metrics=['accuracy'], optimizer=Adam(learning_rate=0.0003))\n",
        "\n",
        "discriminator_unsupervised = build_discriminator_unsupervised(discriminator_net)\n",
        "discriminator_unsupervised.compile(loss='binary_crossentropy', optimizer=Adam())\n",
        "\n",
        "discriminator_supervised.summary()\n",
        "discriminator_unsupervised.summary()"
      ]
    },
    {
      "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",
        "unsupervised_losses = []\n",
        "gen_losses = []\n",
        "iteration_checkpoints = []\n",
        "\n",
        "\n",
        "def train(iterations, batch_size, sample_interval):\n",
        "\n",
        "    real = np.ones((batch_size, 1))\n",
        "    fake = np.zeros((batch_size, 1))\n",
        "\n",
        "    for iteration in range(iterations):\n",
        "        imgs, labels = dataset.batch_labeled(batch_size)\n",
        "\n",
        "        labels = to_categorical(labels, num_classes=num_classes)\n",
        "        imgs_unlabeled = dataset.batch_unlabeled(batch_size)\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",
        "        d_loss_supervised, accuracy = discriminator_supervised.train_on_batch(imgs, labels)\n",
        "\n",
        "        d_loss_real = discriminator_unsupervised.train_on_batch(imgs_unlabeled, real)\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",
        "            unsupervised_losses.append(d_loss_unsupervised)\n",
        "            gen_losses.append(g_loss)\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": "8f5a0357-f581-4df5-ad8c-c0e792afce21",
        "scrolled": true
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "800 [D loss supervised: 0.0277, acc.: 100.00%] [D loss unsupervised: 0.1017] [G loss: 4.740214]\n",
            "1600 [D loss supervised: 0.0178, acc.: 100.00%] [D loss unsupervised: 0.2603] [G loss: 4.489601]\n",
            "2400 [D loss supervised: 0.0125, acc.: 100.00%] [D loss unsupervised: 0.3215] [G loss: 3.634198]\n",
            "3200 [D loss supervised: 0.0020, acc.: 100.00%] [D loss unsupervised: 0.2499] [G loss: 3.204275]\n",
            "4000 [D loss supervised: 0.0010, acc.: 100.00%] [D loss unsupervised: 0.5143] [G loss: 2.915068]\n",
            "4800 [D loss supervised: 0.0019, acc.: 100.00%] [D loss unsupervised: 0.5375] [G loss: 2.721536]\n",
            "5600 [D loss supervised: 0.0006, acc.: 100.00%] [D loss unsupervised: 0.7159] [G loss: 2.580004]\n",
            "6400 [D loss supervised: 0.0000, acc.: 100.00%] [D loss unsupervised: 0.3690] [G loss: 2.472077]\n",
            "7200 [D loss supervised: 0.0010, acc.: 100.00%] [D loss unsupervised: 0.6019] [G loss: 2.385157]\n",
            "8000 [D loss supervised: 0.0001, acc.: 100.00%] [D loss unsupervised: 0.5120] [G loss: 2.315557]\n"
          ]
        }
      ],
      "source": [
        "iterations = 8000\n",
        "batch_size = 32\n",
        "sample_interval = 800\n",
        "\n",
        "train(iterations, batch_size, sample_interval)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "h92u9tEzCUCg",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 563
        },
        "outputId": "96839c31-e971-4b2a-dd05-dd8aead8a78c"
      },
      "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"
          }
        },
        {
          "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": [
        "plt.figure(figsize=(15, 5))\n",
        "plt.plot(iteration_checkpoints, np.array(supervised_losses), label=\"supervised loss\")\n",
        "plt.plot(iteration_checkpoints, np.array(unsupervised_losses), label=\"unsupervised loss\")\n",
        "plt.xticks(iteration_checkpoints, rotation=90)\n",
        "plt.title(\"Discriminator – Loss\")\n",
        "# plt.xlabel(\"Iteration\")\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.legend()\n",
        "plt.show()\n",
        "\n",
        "plt.figure(figsize=(15, 5))\n",
        "plt.plot(iteration_checkpoints, np.array(gen_losses), label=\"gen loss\")\n",
        "plt.xlabel(\"Iteration\")\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.legend()\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b5zD1QwrCUCh"
      },
      "source": [
        "## SGAN 분류기 – 훈련 세트와 테스트 세트 정확도"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "ajShPxUjCUCh",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6c923eff-bdec-46ed-df69-087dc9071266"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4/4 [==============================] - 0s 14ms/step - loss: 1.6376e-05 - 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",
        "_, 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": "abd40fda-f54c-460f-e7bc-79195ae1fb8b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "313/313 [==============================] - 1s 3ms/step - loss: 0.9210 - accuracy: 0.7746\n",
            "Test Accuracy: 77.46%\n"
          ]
        }
      ],
      "source": [
        "x, y = dataset.test_set()\n",
        "y = to_categorical(y, num_classes=num_classes)\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', metrics=['accuracy'], optimizer=Adam())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "_V-rV4SqCUCi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8eeafe34-1401-4931-e82e-071e48c5d72e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/30\n",
            "4/4 [==============================] - 0s 21ms/step - loss: 2.2968 - accuracy: 0.1500\n",
            "Epoch 2/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 2.2213 - accuracy: 0.2900\n",
            "Epoch 3/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 2.1443 - accuracy: 0.4300\n",
            "Epoch 4/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 2.0314 - accuracy: 0.5000\n",
            "Epoch 5/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 1.8558 - accuracy: 0.4500\n",
            "Epoch 6/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 1.7051 - accuracy: 0.5900\n",
            "Epoch 7/30\n",
            "4/4 [==============================] - 0s 5ms/step - loss: 1.4217 - accuracy: 0.7100\n",
            "Epoch 8/30\n",
            "4/4 [==============================] - 0s 5ms/step - loss: 1.1641 - accuracy: 0.7200\n",
            "Epoch 9/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.8927 - accuracy: 0.7800\n",
            "Epoch 10/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.7669 - accuracy: 0.8200\n",
            "Epoch 11/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.5284 - accuracy: 0.9000\n",
            "Epoch 12/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.4462 - accuracy: 0.9000\n",
            "Epoch 13/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.3862 - accuracy: 0.8900\n",
            "Epoch 14/30\n",
            "4/4 [==============================] - 0s 6ms/step - loss: 0.2526 - accuracy: 0.9300\n",
            "Epoch 15/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.1986 - accuracy: 0.9600\n",
            "Epoch 16/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.2169 - accuracy: 0.9100\n",
            "Epoch 17/30\n",
            "4/4 [==============================] - 0s 6ms/step - loss: 0.1779 - accuracy: 0.9500\n",
            "Epoch 18/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.1374 - accuracy: 0.9700\n",
            "Epoch 19/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.1317 - accuracy: 0.9600\n",
            "Epoch 20/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.1097 - accuracy: 0.9800\n",
            "Epoch 21/30\n",
            "4/4 [==============================] - 0s 7ms/step - loss: 0.0862 - accuracy: 0.9700\n",
            "Epoch 22/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.0822 - accuracy: 0.9800\n",
            "Epoch 23/30\n",
            "4/4 [==============================] - 0s 6ms/step - loss: 0.0626 - accuracy: 1.0000\n",
            "Epoch 24/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.0426 - accuracy: 1.0000\n",
            "Epoch 25/30\n",
            "4/4 [==============================] - 0s 5ms/step - loss: 0.0728 - accuracy: 0.9900\n",
            "Epoch 26/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.0500 - accuracy: 1.0000\n",
            "Epoch 27/30\n",
            "4/4 [==============================] - 0s 5ms/step - loss: 0.0432 - accuracy: 0.9900\n",
            "Epoch 28/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.0505 - accuracy: 0.9900\n",
            "Epoch 29/30\n",
            "4/4 [==============================] - 0s 5ms/step - loss: 0.0293 - accuracy: 1.0000\n",
            "Epoch 30/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.0174 - accuracy: 1.0000\n"
          ]
        }
      ],
      "source": [
        "imgs, labels = dataset.training_set()\n",
        "\n",
        "# 레이블을 원-핫 인코딩합니다.\n",
        "labels = to_categorical(labels, num_classes=num_classes)\n",
        "\n",
        "training = mnist_classifier.fit(x=imgs, y=labels, batch_size=32, epochs=30, 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": "50a3caf2-3e4c-4fb7-d3f6-a09d5bd4b354"
      },
      "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": [
        "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": "46254ed0-0007-4a8b-e505-12839a562af1"
      },
      "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": [
        "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": "42f8142a-14d5-408c-ba14-2bd265e3a727"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4/4 [==============================] - 0s 5ms/step - loss: 0.0078 - 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": "261dedd4-bc6b-43b8-ff3e-ee2e59a2cae5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "313/313 [==============================] - 1s 3ms/step - loss: 1.2193 - accuracy: 0.7131\n",
            "Test Accuracy: 71.31%\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))"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "iWXTL0yLcrLx"
      },
      "execution_count": 22,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "name": "Chapter_7_SGAN(edited_exp)",
      "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"
    },
    "accelerator": "GPU"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}