Chapter_7_SGAN(edited_without_Unsupervised).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_without_Unsupervised).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": "46853bf6-c8b3-43c2-c7ab-7b2c9624b5b8"
      },
      "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))\n",
        "            print(\n",
        "                \"%d [D loss supervised: %.4f, acc.: %.2f%%] [G loss: %f]\"\n",
        "                % (iteration + 1, d_loss_supervised, 100 * accuracy, g_loss))\n",
        " "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fy5892ZuCUCf"
      },
      "source": [
        "## 모델 훈련과 출력 조사"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9J7305B3CUCf",
        "outputId": "902e3468-6a84-4422-e8f5-4ce6779f7414",
        "scrolled": true
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "800 [D loss supervised: 0.0097, acc.: 100.00%] [G loss: 0.007831]\n",
            "1600 [D loss supervised: 0.0001, acc.: 100.00%] [G loss: 0.003916]\n",
            "2400 [D loss supervised: 0.0001, acc.: 100.00%] [G loss: 0.002611]\n",
            "3200 [D loss supervised: 0.0001, acc.: 100.00%] [G loss: 0.001958]\n",
            "4000 [D loss supervised: 0.0001, acc.: 100.00%] [G loss: 0.001566]\n",
            "4800 [D loss supervised: 0.0000, acc.: 100.00%] [G loss: 0.001305]\n",
            "5600 [D loss supervised: 0.0000, acc.: 100.00%] [G loss: 0.001119]\n",
            "6400 [D loss supervised: 0.0000, acc.: 100.00%] [G loss: 0.000979]\n",
            "7200 [D loss supervised: 0.0000, acc.: 100.00%] [G loss: 0.000870]\n",
            "8000 [D loss supervised: 0.0001, acc.: 100.00%] [G loss: 0.000783]\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": 556
        },
        "outputId": "9a86be85-0a06-493e-bab1-f1fee256f347"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1080x360 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAA4QAAAFOCAYAAADeotPAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzde5xcdZ3n/9enL7lfgCSEVAIkCAgB0gEDgigjIAJCGt2HjrCrODNeZn8jc1lm8LKOIzOj+9N1Vkd3dHYZUXGc4bLqasJdRRSd4RKQhISAhJskBMgFkpB7uj/7R1WSTqeTdEJVn6rq1/Px6AdV3/M9pz516Jzqd53v+Z7ITCRJkiRJg09L0QVIkiRJkophIJQkSZKkQcpAKEmSJEmDlIFQkiRJkgYpA6EkSZIkDVIGQkmSJEkapAyEkqS6FBH/KyI+XeVt/qeIuPMA131LRDxezXokSSpaeB9CSdJAi4hngInANqALeBT4DnBNZnYXWNqAiIi7ge9m5jcKeO0EjsnMJQP92pKk+uMZQklSUWZn5mjgSODzwMeBa2v1YhHRVqttD6Qo8/NbklQVfqBIkgqVmWsycw7wXuADEXEiQER8OyI+W3k8PiJujohXImJ1RNyzPRRFxOER8YOIWBERqyLiHyrtvxcRv4qIL0fEKuDqStsvt792RGRE/FFEPBER6yLibyPidRHxbxGxNiJuioghlb5vjYilPdZ9JiL+IiIWRMSaiLgxIoZVlh1cqXdFRLxceTylsuxzwFuAf4iIV3vU+6aIeKCyrQci4k09XuvuiPhcRPwK2AAcVe3/DxExNiK+U6n52Yj4yx77+OiI+HmltpURcWOlPSr796XK/npk+/8/SVJjMBBKkupCZt4PLKUclnr788qyCZSHmv5XICOiFbgZeBaYCkwGbuix3huBpyrrfG4PL30+8AbgdOBjwDXA+4DDgROBy/ZS9u8CFwDTgBnA71XaW4BvUT77eQSwEfiHyvv8FHAPcEVmjsrMKyLiEOAW4KvAOOBLwC0RMa7Ha70f+AgwuvJ+q+1/AmMph83fAS4Hfr+y7G+BO4GDgSmVvgBvB84Cjq2s+7vAqhrUJkmqEQOhJKmePA8c0kf7VmAScGRmbs3Me7J8EfxpQAm4KjPXZ+amzPxlz+1l5v/MzG2ZuXEPr/nfM3NtZi4CFgJ3ZuZTmbkGuA04eS/1fjUzn8/M1cBcYCZAZq7KzO9n5obMXEc5jP7OXrZzEfBEZv5zpdbrgceA2T36fDszF1WWb93LtvZbJVhfCnwyM9dl5jPA/6AcQqG8/48ESr328VbKAfU4yvMSLM7M5dWsTZJUWwZCSVI9mQys7qP9i8AS4M6IeCoiPlFpPxx4NjO37WF7z/XjNV/s8XhjH89H7WXdF3o83rC9b0SMiIj/XRl6uRb4BXBQJXj1pcTuZ/2epbw/ttvje4mID1aGn/b8+che6u5tPNDeq4aer/8xIID7I2JRRPwBQGbeRfnM59eAlyLimogYsx+vK0kqmIFQklQXIuJUygHkl72XVc5a/XlmHgV0AldGxLmUQ9IRe5kwpqiptP8ceD3wxswcQ3lYJZRDFexe1/OUz8D1dASwrMfzPb6XzLy2Mvy05881+1HvSnaeBdzt9TPzhcz8cGaWgD8Evh4RR1eWfTUz3wBMpzx09Kr9eF1JUsEMhJKkQkXEmIi4mPK1f9/NzEf66HNxZWKTANZQvlVFN3A/sBz4fESMjIhhEXHmQNa/B6Mpn118pXJ94Gd6LX+RXSeGuRU4NiL+Y0S0RcR7KQesm2tU35DKvhq2fSIc4CbgcxExOiKOBK4EvgsQEe/ZPikO8DLlcNodEadGxBsjoh1YD2yi/P9FktQgDISSpKLMjYh1lM/yfYryRCq/v4e+xwA/AV4F/h34emb+LDO7KF9ndzTwW8oTz7y31oX3w98DwymfebsXuL3X8q8A767MQPrVzFwFXEz5zOIqykM0L87MlTWqbxHlwLr95/eBP6Yc6p6ifJb2X4FvVvqfCtwXEa8Cc4A/zcyngDHAP1EOic9Wav9ijWqWJNWAN6aXJEmSpEHKM4SSJEmSNEgZCCVJkiRpkDIQSpIkSdIgZSCUJEmSpEHKQChJkiRJg9SebuTbVMaPH59Tp04tugxJkiRJKsSDDz64MjMn9G6vaSCMiAso32upFfhGZn6+1/KhwHeAN1C+d9F7M/OZiBgHfI/yfY++nZlX9FjnDcC3Kd/f6VbK90La670zpk6dyrx586r2viRJkiSpkUTEs32112zIaES0Al8DLgSmA5dFxPRe3T4IvJyZRwNfBr5Qad8EfBr4iz42/Y/AhynfpPgY4ILqVy9JkiRJza+W1xCeBizJzKcycwtwA3BJrz6XANdVHn8PODciIjPXZ+YvKQfDHSJiEjAmM++tnBX8DvDOGr4HSZIkSWpatQyEk4HnejxfWmnrs09mbgPWAOP2sc2l+9imJEmSJKkfmnZSmYj4CPARgCOOOKLgaiRJkqT6t3XrVpYuXcqmTZv23Vl1adiwYUyZMoX29vZ+9a9lIFwGHN7j+ZRKW199lkZEGzCW8uQye9vmlH1sE4DMvAa4BmDWrFl7nXRGkiRJEixdupTRo0czdepUIqLocrSfMpNVq1axdOlSpk2b1q91ajlk9AHgmIiYFhFDgEuBOb36zAE+UHn8buCuvc0YmpnLgbURcXqUf0MvB35U/dIlSZKkwWfTpk2MGzfOMNigIoJx48bt1xnemp0hzMxtEXEFcAfl2058MzMXRcTfAPMycw5wLfDPEbEEWE05NAIQEc8AY4AhEfFO4O2Z+SjwR+y87cRtlR9JkiRJVWAYbGz7+/+vlmcIycxbM/PYzHxdZn6u0vZXlTBIZm7KzPdk5tGZeVpmPtVj3amZeUhmjsrMKZUwSGbOy8wTK9u8Yl/3IJQkSZKk/fWmN73pNW/j7rvv5uKLL+53exFqGgglSZIkqR5lJt3d3Xtc/m//9m8DWE1xDIQFWPbKRv74+l+zcNmaokuRJEmS6sb69eu56KKL6Ojo4MQTT+TGG28EYOrUqaxcuRKAefPm8da3vhWAq6++mve///2cccYZHHPMMfzTP/3Tjm198Ytf5NRTT2XGjBl85jOfAeCZZ57h9a9/PZdffjknnngif/u3f8tVV121Y51vf/vbXHHFFQCMGjUKgOXLl3PWWWcxc+ZMTjzxRO655x4A7rzzTs444wxOOeUU3vOe9/Dqq68CcPvtt3Pcccdxyimn8IMf/GCf73n16tW8853vZMaMGZx++uksWLAAgJ///OfMnDmTmTNncvLJJ7Nu3bo91vJaNO1tJ+rZqCFt3L5wORNHD+XEyWOLLkeSJEnazV/PXcSjz6+t6janl8bwmdkn7HH57bffTqlU4pZbbgFgzZp9n0BZsGAB9957L+vXr+fkk0/moosuYuHChTzxxBPcf//9ZCadnZ384he/4IgjjuCJJ57guuuu4/TTT2fFihWcccYZfPGLXwTgxhtv5FOf+tQu2//Xf/1Xzj//fD71qU/R1dXFhg0bWLlyJZ/97Gf5yU9+wsiRI/nCF77Al770JT72sY/x4Q9/mLvuuoujjz6a9773vfus/zOf+Qwnn3wyP/zhD7nrrru4/PLLefjhh/m7v/s7vva1r3HmmWfy6quvMmzYMK655prdanmtPENYgLEj2vmdYw/l5gXL6e72EkhJkiQJ4KSTTuLHP/4xH//4x7nnnnsYO3bfJ08uueQShg8fzvjx4zn77LO5//77ufPOO7nzzjs5+eSTOeWUU3jsscd44oknADjyyCM5/fTTAZgwYQJHHXUU9957L6tWreKxxx7jzDPP3GX7p556Kt/61re4+uqreeSRRxg9ejT33nsvjz76KGeeeSYzZ87kuuuu49lnn+Wxxx5j2rRpHHPMMUQE73vf+/ZZ/y9/+Uve//73A3DOOeewatUq1q5dy5lnnsmVV17JV7/6VV555RXa2tr6rOW18gxhQTpnlvjJ4hd54JnVvPGocUWXI0mSJO1ib2fyauXYY4/loYce4tZbb+Uv//IvOffcc/mrv/or2tradlzv1/uWCr1n1YwIMpNPfvKT/OEf/uEuy5555hlGjhy5S9ull17KTTfdxHHHHce73vWu3bZ31lln8Ytf/IJbbrmF3/u93+PKK6/k4IMP5rzzzuP666/fpe/DDz/8mt5/T5/4xCe46KKLuPXWWznzzDO54447+qzl8ssvf02v4xnCgrzt+EMZ3t7KnPnPF12KJEmSVBeef/55RowYwfve9z6uuuoqHnroIaB8DeGDDz4IwPe///1d1vnRj37Epk2bWLVqFXfffTennnoq559/Pt/85jd3XNe3bNkyXnrppT5f813vehc/+tGPuP7667n00kt3W/7ss88yceJEPvzhD/OhD32Ihx56iNNPP51f/epXLFmyBChf+/ib3/yG4447jmeeeYYnn3wSYLfA2Je3vOUt/Mu//AtQnn10/PjxjBkzhieffJKTTjqJj3/845x66qk89thjfdbyWnmGsCAjhrTxtukTuW3hC1zdeQLtrWZzSZIkDW6PPPIIV111FS0tLbS3t/OP//iPQPk6uw9+8IN8+tOf3jGhzHYzZszg7LPPZuXKlXz605+mVCpRKpVYvHgxZ5xxBlCeIOa73/0ura2tu73mwQcfzPHHH8+jjz7Kaaedttvyu+++my9+8Yu0t7czatQovvOd7zBhwgS+/e1vc9lll7F582YAPvvZz3LsscdyzTXXcNFFFzFixAje8pa3sG7dur2+56uvvpo/+IM/YMaMGYwYMYLrrrsOgL//+7/nZz/7GS0tLZxwwglceOGF3HDDDbvV8lrFYLiN36xZs3LevHlFl7GbHz/6Ih/+zjy+/fun8tbXH1p0OZIkSRrkFi9ezPHHH190Gf129dVXM2rUKP7iL/6i6FLqSl//HyPiwcyc1buvp6UKdNax4xkzrM1ho5IkSZIK4ZDRAg1ta+WCEw/j1kdeYNPWLoa1734KW5IkSVLfrr766qJLaHieISxYZ8dkXt28jbsf7/siV0mSJEmqFQNhwU4/6hDGjxrisFFJkiTVhcEwx0gz29//fwbCgrW1tnDRSZP46eKXWLdpa9HlSJIkaRAbNmwYq1atMhQ2qMxk1apVDBs2rN/reA1hHeicWeK6f3+Wnyx+kXedPKXociRJkjRITZkyhaVLl7JixYqiS9EBGjZsGFOm9D9TGAjrwClHHMzkg4Yz5+HnDYSSJEkqTHt7O9OmTSu6DA0gh4zWgYjg4o5J3PPESl5ev6XociRJkiQNEgbCOtHZUWJbd3LbwheKLkWSJEnSIGEgrBPTJ43hdRNGMmf+sqJLkSRJkjRIGAjrREQwu6PEfU+v5oU1m4ouR5IkSdIgYCCsI50dJTLhlkeWF12KJEmSpEHAQFhHjpowihMnj/Em9ZIkSZIGhIGwzsyeUWL+c6/w7Kr1RZciSZIkqckZCOvMxR0lAG5e4LBRSZIkSbVlIKwzkw8azqlTD2bOww4blSRJklRbBsI6NLujxOMvruPxF9YVXYokSZKkJmYgrEPvOGkSrS3BXCeXkSRJklRDBsI6NH7UUN70unHMmf88mVl0OZIkSZKalIGwTs3uKPHb1RuYv3RN0aVIkiRJalIGwjp1/gmHMaS1xWGjkiRJkmrGQFinxg5v562vn8DNC56nq9tho5IkSZKqz0BYx2Z3lHhx7Wbuf3p10aVIkiRJakIGwjr2tuMnMmJIK3MXOGxUkiRJUvUZCOvY8CGtnDd9Irc9spytXd1FlyNJkiSpyRgI69zsGSVe3rCVXz6xsuhSJEmSJDUZA2GdO+vYCYwd3s4cZxuVJEmSVGUGwjo3pK2FC088jDsXvcCmrV1FlyNJkiSpiRgIG8DsjhLrt3Rx12MvFV2KJEmSpCZiIGwApx81jgmjhzLnYYeNSpIkSaoeA2EDaG0JLjppEnc9/hLrNm0tuhxJkiRJTcJA2CA6Z5bYsq2bOxe9WHQpkiRJkpqEgbBBnHz4QUw5eLizjUqSJEmqGgNhg4gIZneU+OWSlaxev6XociRJkiQ1gZoGwoi4ICIej4glEfGJPpYPjYgbK8vvi4ipPZZ9stL+eESc36P9v0TEoohYGBHXR8SwWr6HetLZUaKrO7n1keVFlyJJkiSpCdQsEEZEK/A14EJgOnBZREzv1e2DwMuZeTTwZeALlXWnA5cCJwAXAF+PiNaImAz8CTArM08EWiv9BoXjDhvN0YeOctioJEmSpKqo5RnC04AlmflUZm4BbgAu6dXnEuC6yuPvAedGRFTab8jMzZn5NLCksj2ANmB4RLQBI4BBk44igs6OEg88s5rlazYWXY4kSZKkBlfLQDgZeK7H86WVtj77ZOY2YA0wbk/rZuYy4O+A3wLLgTWZeWdNqq9TsztKZMItCxw2KkmSJOm1aahJZSLiYMpnD6cBJWBkRLxvD30/EhHzImLeihUrBrLMmpo2fiQnTR7rsFFJkiRJr1ktA+Ey4PAez6dU2vrsUxkCOhZYtZd13wY8nZkrMnMr8APgTX29eGZek5mzMnPWhAkTqvB26kdnR4kFS9fwzMr1RZciSZIkqYHVMhA+ABwTEdMiYgjlyV/m9OozB/hA5fG7gbsyMyvtl1ZmIZ0GHAPcT3mo6OkRMaJyreG5wOIavoe6dHHHJADmepZQkiRJ0mtQs0BYuSbwCuAOyqHtpsxcFBF/ExGdlW7XAuMiYglwJfCJyrqLgJuAR4HbgY9mZldm3kd58pmHgEcq9V9Tq/dQryaNHc5pUw9hzvznKednSZIkSdp/MRgCxaxZs3LevHlFl1FV/3zvs3z6hwu5/c/ewnGHjSm6HEmSJEl1LCIezMxZvdsbalIZ7fSOEw+jtSWY87DDRiVJkiQdGANhgxo3aihnHj2euQscNipJkiTpwBgIG1hnR4nnVm/k4edeKboUSZIkSQ3IQNjA3n7CRIa0tXhPQkmSJEkHxEDYwMYMa+fs10/g5gXL6ep22KgkSZKk/WMgbHCdHZNZsW4z9z21quhSJEmSJDUYA2GDO+e4Qxk5pJW5Cxw2KkmSJGn/GAgb3PAhrZw3fSK3PvICW7Z1F12OJEmSpAZiIGwCnTNLrNm4lXueWFF0KZIkSZIaiIGwCbz56AkcNKKduc42KkmSJGk/GAibwJC2Fi488TDufPRFNm7pKrocSZIkSQ3CQNgkZneU2LCli58+9mLRpUiSJElqEAbCJvHGaeM4dPRQh41KkiRJ6jcDYZNobQkumjGJnz2+grWbthZdjiRJkqQGYCBsIp0dJbZs6+aOhS8UXYokSZKkBmAgbCIzDz+IIw4ZwdwFy4suRZIkSVIDMBA2kYhgdsckfrVkJate3Vx0OZIkSZLqnIGwyczuKNHVndz6iGcJJUmSJO2dgbDJHHfYGI6dOIq58w2EkiRJkvbOQNiEOjtK3P/Map5/ZWPRpUiSJEmqYwbCJnTxjBIANy/wnoSSJEmS9sxA2ISmjh9Jx5SxDhuVJEmStFcGwiY1u6PEI8vW8PTK9UWXIkmSJKlOGQib1MUzSkTAnIcdNipJkiSpbwbCJnXY2GGcNvUQ5sxfRmYWXY4kSZKkOmQgbGKdM0s8uWI9i5evK7oUSZIkSXXIQNjELjxxEm0twZz5DhuVJEmStDsDYRM7ZOQQ3nzMeObOf95ho5IkSZJ2YyBscp0dJZa9spGHfvtK0aVIkiRJqjMGwiZ33vSJDG1rYa7DRiVJkiT1YiBscqOHtXPOcYdy84LlbOvqLrocSZIkSXXEQDgIdHaUWPnqZu57enXRpUiSJEmqIwbCQeDs4w5l1NA2b1IvSZIkaRcGwkFgWHsrb58+kdsWLmfztq6iy5EkSZJUJwyEg8TsmSXWbtrGPb9ZWXQpkiRJkuqEgXCQePPR4zl4RLs3qZckSZK0g4FwkGhvbeHCkybx40dfZMOWbUWXI0mSJKkOGAgHkc6OEhu3dvHTxS8VXYokSZKkOmAgHEROnXoIE8cMddioJEmSJMBAOKi0tgQXzyjx88dXsGbj1qLLkSRJklQwA+Eg09lRYktXN3cseqHoUiRJkiQVzEA4yMyYMpYjx41grsNGJUmSpEGvpoEwIi6IiMcjYklEfKKP5UMj4sbK8vsiYmqPZZ+stD8eEef3aD8oIr4XEY9FxOKIOKOW76HZRASzZ5T41ZKVrFi3uehyJEmSJBWoZoEwIlqBrwEXAtOByyJieq9uHwRezsyjgS8DX6isOx24FDgBuAD4emV7AF8Bbs/M44AOYHGt3kOz6pxZojvhtoXLiy5FkiRJUoFqeYbwNGBJZj6VmVuAG4BLevW5BLiu8vh7wLkREZX2GzJzc2Y+DSwBTouIscBZwLUAmbklM1+p4XtoSsdOHM1xh41mzsMOG5UkSZIGs1oGwsnAcz2eL6209dknM7cBa4Bxe1l3GrAC+FZE/DoivhERI/t68Yj4SETMi4h5K1asqMb7aSqzO0rMe/Zllr2ysehSJEmSJBWk0SaVaQNOAf4xM08G1gO7XZsIkJnXZOaszJw1YcKEgayxIcyeUQJwchlJkiRpEKtlIFwGHN7j+ZRKW599IqINGAus2su6S4GlmXlfpf17lAOi9tMR40Yw8/CDDISSJEnSIFbLQPgAcExETIuIIZQniZnTq88c4AOVx+8G7srMrLRfWpmFdBpwDHB/Zr4APBcRr6+scy7waA3fQ1Ob3VFi0fNreXLFq0WXIkmSJKkANQuElWsCrwDuoDwT6E2ZuSgi/iYiOivdrgXGRcQS4Eoqwz8zcxFwE+Wwdzvw0czsqqzzx8C/RMQCYCbw32r1HprdxTMmEYGTy0iSJEmDVJRPyDW3WbNm5bx584ouoy5dds29vLhuEz+98ncoT/AqSZIkqdlExIOZOat3e6NNKqMqm91R4qkV61n0/NqiS5EkSZI0wAyEg9yFJx5GW0s4uYwkSZI0CBkIB7mDRw7hrGMncPOC5XR3N//wYUmSJEk7GQjF7I5JLHtlIw/99uWiS5EkSZI0gAyE4rzphzG0rYU5DhuVJEmSBhUDoRg1tI23HT+RWx9Zzrau7qLLkSRJkjRADIQCysNGV766hX9/alXRpUiSJEkaIAZCAfDW1x/K6KFt3qRekiRJGkQMhAJgWHsrbz/hMG5f9AKbt3UVXY4kSZKkAWAg1A6zOyaxbtM2fv74iqJLkSRJkjQADITa4cyjx3PIyCHONipJkiQNEgZC7dDe2sI7TjqMny5+iQ1bthVdjiRJkqQaMxBqF7NnlNi4tYsfP/pi0aVIkiRJqjEDoXZx6tRDmDR2GHMdNipJkiQ1PQOhdtHSElw8YxI//80K1mzYWnQ5kiRJkmqoX4EwIkZGREvl8bER0RkR7bUtTUWZ3VFia1dy+6LlRZciSZIkqYb6e4bwF8CwiJgM3Am8H/h2rYpSsU6aPJap40Y426gkSZLU5PobCCMzNwD/Afh6Zr4HOKF2ZalIEUFnR4l/f3IVL63bVHQ5kiRJkmqk34EwIs4A/hNwS6WttTYlqR7M7ijRnXDrAoeNSpIkSc2qv4Hwz4BPAv83MxdFxFHAz2pXlop2zMTRHHfYaIeNSpIkSU2sX4EwM3+emZ2Z+YXK5DIrM/NPalybCtY5s8RDv32F51ZvKLoUSZIkSTXQ31lG/zUixkTESGAh8GhEXFXb0lS02TNKANzssFFJkiSpKfV3yOj0zFwLvBO4DZhGeaZRNbHDDxnByUcc5LBRSZIkqUn1NxC2V+47+E5gTmZuBbJ2ZaledHaUWLx8LUteWld0KZIkSZKqrL+B8H8DzwAjgV9ExJHA2loVpfpx0YxJtATMme+wUUmSJKnZ9HdSma9m5uTMfEeWPQucXePaVAcOHT2M048ax9z5z5PpSWFJkiSpmfR3UpmxEfGliJhX+fkflM8WahDo7Cjx9Mr1LFzmSWFJkiSpmfR3yOg3gXXA71Z+1gLfqlVRqi8XnHgY7a3B3AVOLiNJkiQ1k/4Gwtdl5mcy86nKz18DR9WyMNWPg0YM4axjJjB3/vN0dztsVJIkSWoW/Q2EGyPizdufRMSZwMbalKR61DmzxPI1m5j37MtFlyJJkiSpStr62e8/A9+JiLGV5y8DH6hNSapHbzt+IsPaW5g7/3lOm3ZI0eVIkiRJqoL+zjI6PzM7gBnAjMw8GTinppWprowc2sa5x0/k1keWs62ru+hyJEmSJFVBf4eMApCZazNz+1STV9agHtWxzo4Sq9Zv4VdPriq6FEmSJElVsF+BsJeoWhVqCG99/QRGD2tj7nxnG5UkSZKawWsJhE43OcgMbWvl/BMO446FL7Bpa1fR5UiSJEl6jfYaCCNiXUSs7eNnHVAaoBpVRzo7SqzbvI27H19RdCmSJEmSXqO9BsLMHJ2ZY/r4GZ2Z/Z2hVE3kTa8bx7iRQ7xJvSRJktQEXsuQUQ1Cba0tvOOkSfx08Yus37yt6HIkSZIkvQYGQu23zpklNm3t5sePvlh0KZIkSZJeAwOh9tsbjjiY0thhzHG2UUmSJKmhGQi131pagos7SvziNyt4ZcOWosuRJEmSdIAMhDognR0ltnUnty18oehSJEmSJB2gmgbCiLggIh6PiCUR8Yk+lg+NiBsry++LiKk9ln2y0v54RJzfa73WiPh1RNxcy/q1ZyeUxnDU+JHMedhho5IkSVKjqlkgjIhW4GvAhcB04LKImN6r2weBlzPzaODLwBcq604HLgVOAC4Avl7Z3nZ/CiyuVe3at4hgdkeJe59exUtrNxVdjiRJkqQDUMszhKcBSzLzqczcAtwAXNKrzyXAdZXH3wPOjYiotN+QmZsz82lgSWV7RMQU4CLgGzWsXf0wu6NEJty8YHnRpUiSJEk6ALUMhJOB53o8X1pp67NPZm4D1gDj9rHu3wMfA7r39uIR8ZGImBcR81asWHGg70F7cfSho5g+aYyzjUqSJEkNqqEmlYmIi4GXMvPBffXNzGsyc1ZmzpowYcIAVDc4dc4s8fBzr/Dc6g1FlyJJkiRpP9UyEC4DDu/xfEqlrc8+EdEGjAVW7WXdM4HOiHiG8hDUcyLiu7UoXv1z8YxJAJ4llCRJkhpQLZDKmwQAABzLSURBVAPhA8AxETEtIoZQniRmTq8+c4APVB6/G7grM7PSfmllFtJpwDHA/Zn5ycyckplTK9u7KzPfV8P3oH2YcvAI3nDkwcw1EEqSJEkNp2aBsHJN4BXAHZRnBL0pMxdFxN9ERGel27XAuIhYAlwJfKKy7iLgJuBR4Hbgo5nZVata9dp0dpR47IV1/ObFdUWXIkmSJGk/RPmEXHObNWtWzps3r+gymtaKdZt543/7CR89+2j+/O2vL7ocSZIkSb1ExIOZOat3e0NNKqP6NGH0UN70uvHMmf88g+ELBkmSJKlZGAhVFZ0dJZ5dtYFHlq0puhRJkiRJ/WQgVFWcf8JhtLcGcx52chlJkiSpURgIVRVjR7TzO8ceys0LltPd7bBRSZIkqREYCFU1nTNLvLB2Ew88s7roUiRJkiT1g4FQVfO24w9leHurN6mXJEmSGoSBUFUzYkgbb5s+kVsfWc7Wru6iy5EkSZK0DwZCVVVnR4mXN2zlV0tWFl2KJEmSpH0wEKqqzjp2PGOGtTlsVJIkSWoABkJV1dC2Vi448TDuXPQim7Z2FV2OJEmSpL0wEKrqOjsm8+rmbfzssZeKLkWSJEnSXhgIVXWnH3UI40cNYe4Ch41KkiRJ9cxAqKpra23hopMm8dPFL7Fu09aiy5EkSZK0BwZC1UTnzBKbt3Xz40dfLLoUSZIkSXtgIFRNnHz4wUw+aDhznW1UkiRJqlsGQtVES0twccck7nliJS+v31J0OZIkSZL6YCBUzXR2lNjWndy6cHnRpUiSJEnqg4FQNTN90hiOmjDSYaOSJElSnTIQqmYigs6OEvc9vZoX1mwquhxJkiRJvRgIVVOdHSUy4WbvSShJkiTVHQOhauqoCaM4cfIY5i7wOkJJkiSp3hgIVXOzZ5SY/9wrPLtqfdGlSJIkSerBQKiau7ijBODkMpIkSVKdMRCq5iYfNJxTpx7M3PkOG5UkSZLqiYFQA2J2R4nHX1zH4y+sK7oUSZIkSRUGQg2Id5w0idaWYM78ZUWXIkmSJKnCQKgBMX7UUN70unHMnb+czCy6HEmSJEkYCDWAZneU+O3qDcxfuqboUiRJkiRhINQAOv+EwxjS2sKch51tVJIkSaoHBkINmLHD23nr6ydw84Ln6ep22KgkSZJUNAOhBtTsjhIvrdvM/U+vLroUSZIkadAzEGpAve34iYwY0socb1IvSZIkFc5AqAE1fEgr502fyG0Ll7NlW3fR5UiSJEmDmoFQA272jBKvbNjKr5asLLoUSZIkaVAzEGrAnXXsBMYOb3fYqCRJklQwA6EG3JC2Fi488TDuXPQCG7d0FV2OJEmSNGgZCFWI2R0l1m/p4mePv1R0KZIkSdKgZSBUIU4/ahwTRg/1JvWSJElSgQyEKkRrS3DRSZO46/GXWLtpa9HlSJIkSYOSgVCFmd1RYsu2bn686MWiS5EkSZIGJQOhCnPKEQcx5eDhzjYqSZIkFcRAqMJEBLM7SvxyyUpWvbq56HIkSZKkQaemgTAiLoiIxyNiSUR8oo/lQyPixsry+yJiao9ln6y0Px4R51faDo+In0XEoxGxKCL+tJb1q/ZmzyjR1Z3ctvCFokuRJEmSBp2aBcKIaAW+BlwITAcui4jpvbp9EHg5M48Gvgx8obLudOBS4ATgAuDrle1tA/48M6cDpwMf7WObaiDHTxrN0YeOctioJEmSVIBaniE8DViSmU9l5hbgBuCSXn0uAa6rPP4ecG5ERKX9hszcnJlPA0uA0zJzeWY+BJCZ64DFwOQavgfVWETQ2VHigWdWs3zNxqLLkSRJkgaVWgbCycBzPZ4vZffwtqNPZm4D1gDj+rNuZXjpycB9fb14RHwkIuZFxLwVK1Yc8JtQ7c3uKJEJtyxYXnQpkiRJ0qDSkJPKRMQo4PvAn2Xm2r76ZOY1mTkrM2dNmDBhYAvUfpk2fiQnTR7rsFFJkiRpgNUyEC4DDu/xfEqlrc8+EdEGjAVW7W3diGinHAb/JTN/UJPKNeA6O0osWLqGp1euL7oUSZIkadCoZSB8ADgmIqZFxBDKk8TM6dVnDvCByuN3A3dlZlbaL63MQjoNOAa4v3J94bXA4sz8Ug1r1wC7uGMSADd7llCSJEkaMDULhJVrAq8A7qA8+ctNmbkoIv4mIjor3a4FxkXEEuBK4BOVdRcBNwGPArcDH83MLuBM4P3AORHxcOXnHbV6Dxo4k8YO57SphzBn/vOUvxOQJEmSVGsxGP74njVrVs6bN6/oMrQP/3zvs3z6hwu57U/fwvGTxhRdjiRJktQ0IuLBzJzVu70hJ5VRc3rHiYfR2hLMddioJEmSNCAMhKob40YN5cyjxzN3gcNGJUmSpIFgIFRd6ewo8dzqjfz6uVeKLkWSJElqegZC1ZW3nzCRIW0tzHnYYaOSJElSrRkIVVfGDGvn7NdP4JZHltPV7bBRSZIkqZYMhKo7nR2TWbFuM/c9taroUiRJkqSmZiBU3TnnuEMZOaSVOc42KkmSJNWUgVB1Z/iQVs6bPpHbFr7Alm3dRZcjSZIkNS0DoepS58wSazZu5Z4nVhRdiiRJktS0DISqS28+egIHjWh32KgkSZJUQwZC1aUhbS1ceOJh/PjRF9m4pavociRJkqSmZCBU3ZrdUWLDli5++tiLRZciSZIkNSUDoerWG6eN49DRQ71JvSRJklQjBkLVrdaW4KIZk7j78RWs3bS16HIkSZKkpmMgVF3r7CixpaubOxa+UHQpkiRJUtMxEKquzTz8IA4/ZLizjUqSJEk1YCBUXYsIZs8o8W9PrmLlq5uLLkeSJElqKgZC1b3OmSW6upPbHlledCmSJElSUzEQqu4dd9gYjp04ymGjkiRJUpUZCNUQOjtKPPDMyzz/ysaiS5EkSZKahoFQDeHiGSUAbl7gWUJJkiSpWgyEaghTx4+kY8pYh41KkiRJVWQgVMOY3VFi4bK1PLXi1aJLkSRJkpqCgVAN4+IZJSJg7nxnG5UkSZKqwUCohnHY2GGcNvUQ5sxfRmYWXY4kSZLU8AyEaiidM0s8uWI9jy5fW3QpkiRJUsMzEKqhXHjiJNpawmGjkiRJUhUYCNVQDhk5hDcfM56585932KgkSZL0GhkI1XA6O0ose2UjD/325aJLkSRJkhqagVAN57zpExna1uKwUUmSJOk1MhCq4Ywe1s45xx3KzQuWs62ru+hyJEmSpIZlIFRD6uwosfLVzdz71OqiS5EkSZIaloFQDens4w5l1NA25s5/vuhSJEmSpIZlIFRDGtbeytunT+S2hcvZvK2r6HIkSZKkhmQgVMOaPbPE2k3b+MVvVhZdiiRJktSQDIRqWG8+ejwHj2h32KgkSZJ0gAyEaljtrS1ceNIkfvzoi2zYsq3ociRJkqSGYyBUQ+vsKLFxaxc/WfxS0aVIkiRJDcdAqIZ26tRDmDhmqMNGJUmSpANgIFRDa20JLp5R4uePr2DNxq1FlyNJkiQ1lLaiC5Beq86OEtf+8mnuWPgCv3vq4UWXoyrITLqzx39JMin/sOsyErozSfbdf3tb7/7s6FPp373rNvbWv3v7dvfQv+c2+yPitfcJ+rOR17SY6Eeh+97GPjexz/cypK2FEUNaGdbeyvAhrQxvb2XEkFaGtrX0q0ZJkgY7A6Ea3owpYzly3Aj+18+fZP7SVyp/iAMkVB5v/6N8x/MdfSrtub135Y/4XZbvbNvesP2P/53by179e71+ZRs9l/d8Pdi1nu017/J8T6/fq74dfXd7vd77Yx+v32tf9Bm2erR176i5V5jbwza2h7ndAp5UJdvDYc+wuOO/2x/3ft6f/1YeGzolqfF1dyebtnWxcUsXm7Z1l/+7tfyzcWu5fePWLjZv7S4/77Fs05btz7t3tG/a2sWnLprOzMMPKvqt9VtNA2FEXAB8BWgFvpGZn++1fCjwHeANwCrgvZn5TGXZJ4EPAl3An2TmHf3ZpgafiOBDb57GV376BHcsegGIHWcegvJZiO1nGcqPdz27EUGP/rGjz/Ztx/YNseu6fW2bvpbvYdtUth29tr3ztSvb7v1eIna8x369fq/3svOt72M/RY+aI2jpse+2L2up9GuJ7dvq1baX/vS1jcqLt/RatsdtsPO1A2hp2fNrbn//O/r3uY299+/dtrPmnY931tDHNvZxtqvH1w577rOPLv3J1LmPjexrG/uqoT9b6c82+lPHlm3lD+ENW7aVP6C3dLFxazcbt2zb8cG9cUs3G7du2/Gh/srGrSxfs3Hnskrf/f1CIoIdAXFYJXwOH9Lj8fZlQ1oZ0b5z2fBefXsH1+3rDms3dEoavLZ2dfcIXt27BLFyQOt5jO8R4rZ0VQJej/V7hLvNldC3fTtbtvVzCE8vQ9paenwGtOzy5WOjiX39YXDAG45oBX4DnAcsBR4ALsvMR3v0+SNgRmb+54i4FHhXZr43IqYD1wOnASXgJ8CxldX2us2+zJo1K+fNm1fV9ydJah6ZyZaubjZt6WZDj/C4aWsXG7Z07f688s3whh5/VPTsu/2Pjw1bdv6BsmFrVz/D9E4t20PnHsJj7zOXI4aUA+j+nPUc0lrfoXPn0OteIw56jJSgV1vvvttHI+zst/u22NFe2V7vbe11VEjPkSW7juro+QVRS+ULr51fNO36vKVHnyCIFnZfh923IQ2UzGTztp5Bq3uX42PP4LVpW/eOM2i7BbZeZ9t2rte9I+htO4BhQ72/qBvW3lI+frbtehwd1t6y4wu77cu2rze0smzX/jvXKY8QaaW1pfH+7UXEg5k5q3d7Lc8QngYsycynKgXcAFwC9AxvlwBXVx5/D/iHKB/ZLgFuyMzNwNMRsaSyPfqxTUmS9ktEMLSt/CE/lvaavEbvP6Q2bukRGHuFx76e9/xGe+OWLlav39LnsgMPnW0MbWvZUWufw83ZPfTsNsx++xD2fYS4nX32vC3t284guXNUx96D587HLT1GYPR3nd7LWno8D4KWlj7Wodc6LTsDcnkURf9fpz+jLbR/tnV373m4ZM+hkpUzbwfy77O9NSqhqnW3s2qHjBzSI3TtGtiGD2llaHvPL7laGNa284uvXbY3pKXuv+CqV7UMhJOB53o8Xwq8cU99MnNbRKwBxlXa7+217uTK431tE4CI+AjwEYAjjjjiwN6BJElVErHzD6JaXVmyPXT2Do89/9v7rGfPvpu3dldq3XUo+c4h6bBjyHqv5dv/6N/5fnsv62sY/p63tX1Y/d621XPZ3uvewxD9Xq+123o9t9/jPe6sYdf30fu1gthtYqvuyvXS5QmptrftfN7do88BrVMJ2N3dvdZh1+12d/exTp+vs+t13t092ncu396nm+zq/zo72rbX1t1rHXZ93t2dfllQZQm0tUaPs2OtDK+cVRs7vH2XEQd7OqvW++xZ77Nqw9pbaW/1xgb1rGknlcnMa4BroDxktOByJEmquZ6h8+Cii5EkNYRaxvVlQM97AEyptPXZJyLagLGUJ5fZ07r92aYkSZIkqR9qGQgfAI6JiGkRMQS4FJjTq88c4AOVx+8G7sryLDdzgEsjYmhETAOOAe7v5zYlSZIkSf1QsyGjlWsCrwDuoHyLiG9m5qKI+BtgXmbOAa4F/rkyacxqygGPSr+bKE8Wsw34aGZ2AfS1zVq9B0mSJElqZjW77UQ98bYTkiRJkgazPd12wil/JEmSJGmQMhBKkiRJ0iBlIJQkSZKkQcpAKEmSJEmDlIFQkiRJkgYpA6EkSZIkDVIGQkmSJEkapAbFfQgjYgXwbNF19GE8sLLoIpqI+7P63KfV5f6sPvdpdbk/q899Wl3uz+pzn1Zfve7TIzNzQu/GQREI61VEzOvr5pA6MO7P6nOfVpf7s/rcp9Xl/qw+92l1uT+rz31afY22Tx0yKkmSJEmDlIFQkiRJkgYpA2Gxrim6gCbj/qw+92l1uT+rz31aXe7P6nOfVpf7s/rcp9XXUPvUawglSZIkaZDyDKEkSZIkDVIGQkmSJEkapAyEkiRJkjRItRVdwGATEYcAZObqomuReoqIscAFwORK0zLgjsx8pbiqGpv7tLoiIoDT2HV/3p9eDH/A3KfVFxHHAZew6z6dk5mLi6uqcXkcrT5/R6urGY6jniEcABFxRETcEBErgPuA+yPipUrb1GKra1wRcVxEfDwivlr5+XhEHF90XY0oIi4HHgLeCoyo/JwNPFhZpv3kPq2uiHg78ARwNfCOys9fA09Ulmk/uU+rLyI+DtwABHB/5SeA6yPiE0XW1og8jlafv6PV1SzHUWcZHQAR8e/A3wPfy8yuSlsr8B7gzzLz9CLra0SVA9pllA9qSyvNU4BLgRsy8/NF1daIIuJx4I29v3GNiIOB+zLz2GIqa1zu0+qKiMXAhZn5TK/2acCtmemXQfvJfVp9EfEb4ITM3NqrfQiwKDOPKaayxuRxtPr8Ha2uZjmOOmR0YIzPzBt7NlSC4Q0R8bcF1dToPkjfB7QvAYsAA+H+CaCvb4e6K8u0/9yn1dXGzi9/eloGtA9wLc3CfVp93UAJeLZX+6TKMu0fj6PV5+9odTXFcdRAODAejIivA9cBz1XaDgc+APy6sKoamwe06voc8FBE3MnO39EjgPMAv7Q4MO7T6vom8EBE3MCux9FLgWsLq6qxuU+r78+An0bEE+z67/5o4IrCqmpcHkerz9/R6mqK46hDRgdA5TT8B+njAl7g2szcXFRtjSoiLgD+gfK47d0OaJl5e1G1NarKEJzz2f3C/ZeLq6qxuU+rKyKmA53sPhHCo8VV1djcp9UXES3sPsHEA9svGdH+8Thaff6OVlczHEcNhGpYHtCqLyIm0mN/ZuaLRdbTDNyn1edszdXnPq2eZphxsN54HK0uf0dro5GPow4ZHQAR0Ub5DOE72fUf348onyHcuqd1tVfZ42f7c4eLHoCImAn8L2As5bHwAUyJiFeAP8rMh4qsrxG5T6srIo4A/jtwDrCm3BRjgLuAT/S+oF/75j6tvsqsgl+nPHplWaV5CnB0RPxRZt5ZWHENyONo9fk7Wl3Nchz1DOEAiIjrgVcoX0PYc0bMDwCHZOZ7i6qtUe3tgEb5Q8ID2n6IiIeBP8zM+3q1nw7878zsKKayxuU+rS5na64+92n1NcuMg/XC42j1+TtaXc1yHDUQDoCI+M2epkbe2zLtmQe06oqIJ/Y01XRELMnMowe6pkbnPq2ufezPPS7TnrlPq68yUcfxmbmtV/sQ4FH/3e8fj6PV5+9odTXLcdQhowNjdUS8B/h+ZnbDjuvf3gN4UfSBaYppfuvIbRFxC/Addp0l63LACXoOjPu0upytufrcp9XX14yDRwDvpYFmHKwjHkerrylmxawjTXEc9QzhAIiIqcAXgLMpDx0FOAj4GeXxxU8XU1njiohPAr9L+cb0vT90b8rM/7+o2hpVRFxIHzPhZuatxVXV2Nyn1eNszdXnPq2NiDievv/dN8yMg/XE42j1NcOsmPWiWY6jBsIBUPlluQx4HngIuAA4k/IN1K9xUpkD44dubUXEoZn5UtF1SFIji4hxmbmq6DqahZ9NUvUZCAdARPwL5SGOwynPQDQS+L/AuZT/H3ygwPKahh+6B277VMm9PAScTPl3tOGmUC5a5aLyD1Ge7Oi2zPy3Hsv+MjM/W1hxDcjZmqsvIo4C/pLyfvwC8GXgDGAxcFWjzI5XTyLi88DfZebKiHgD8H+ALmAIcHlm/rzQAhuMn03VV5kB85OUP5tuzczreyz7emb+UWHFNaBm+WwyEA6AiFiQmTMqvzTLgFJmdlXuAzM/M2cUXGLD8UO3uiKiG3i2V/MUytdpZmYeNfBVNbaI+AYwArgfeD/w88y8srLsocw8pcj6Go2zNVdfRPwCuJ7ylP7vA74N3Ai8HfhPmXlOcdU1poh4JDNPqjz+GfCxzHwgIo4F/jUzZxVbYWPxs6n6IuL7lGdovxf4A2Ar8B8zc7OfTfuvWT6bDIQDICIWAqdQPjP4W+DIzFwdEcOAXzsj5v7zQ7e6IuLPgfMonxV4pNL2dGZOK7ayxrX9i6DK4zbKt0kZT3n4+L2ZeXKR9TUaZ2uuvoj49fbfw4j4bWYe0dcy9V9lBuyTMnNbRNzbc8r5np9b6h8/m6ovIh7OzJk9nn8KeAflawp/bCDcP83y2dRSdAGDxLXAY8DDwKeA/xMR/wQ8QHlSFO2/tsof2QDDM/MBgMz8DTC0uLIaU2b+D8rDG/8qIr4UEaMBvy16bYZsf5CZ2zLzI8B8yjerHVVYVY1rdUS8pzJDM1CerTki3ouzNR+o7og4NiJOBUZExCyAiDgaaC22tIb1deDWiDgHuD0ivhIRvxMRf035bwDtBz+bamJoz+NoZn4O+CfgF8C4wqpqXE3x2eQZwgESESWAzHw+Ig4C3gb8NjPvL7ayxhQRfwzMBj4PnAUcDPwAOAc4KjPfX2B5DS0iOoH/CkzNzMOKrqdRRcR3ge9m5u292j8E/GNmenuU/dBjtuZzKH/IBuWhjs7WfIAi4lzKAaYb+DDwX4AZlPfrRzLzhwWW17Ai4q3A/wccS3n+gOeAHwLfapTrieqRn03VERH/HbgzM3/Sq/0C4H82yn3z6kWz3EnAQKiGtZcP3W/2vuGq9i0ijqN8QfR9lK/HfF1mLoyIC3qHGvVPRJxG+TqXByrTfF8APOZ06a9NRGz/Fvsrmfm+QotpMhFxM9C5/Z65em0i4i3AacAjmXln0fU0moh4I7A4M9dGxAjgasqX4DwI/LfMXFNkfY0oIv4E+L+Z+dw+O2ufmuVOAgZCNZ2I+P3M/FbRdTSSygfERynPLjgT+NPM/FFlmReZH4CI+AxwIeUvK34MvJHyN4bnAXdUhumonyJiTh/N51Aegktmdg5sRY3PfVp9EXF/Zp5WefwhysfVH1KeqGduZn6+yPoaTUQsAjoq12ReA6wHvk95lvaOzPwPhRbYgCJiDeX9+CTlSaX+T2auKLaqxtUsdxIwEKrp9J4cQfsWEY8AZ2Tmq5XhD98D/jkzv+LkEgemsk9nUr6m9QVgSuVb7uHAfc4uvH8i4iHgUeAblK8hCsp/zFwK4MzC+y8ifk35W2z3aZX0mqjnAeAdmbkiIkZSnkzKSWX2Q0Qs3j7xXu8vJ3tPjqL+qfy7fwPlS5feS3kymQcp/9v/QWauK7C8htMsdxJo23cXqf5ExII9LQImDmQtTaIlM18FyMxnKsNxvxcRR1Lep9p/2zKzC9gQEU9m5lqAzNxYmUpd+2cW8KeUJ+a6KjMfjoiNhpbX5A24T6utJSIOpjxpX2w/85KZ6yPCSxn238Ieo37mR8SszJxXmVG8IYbi1aGsDAm/E7gzItopj2a5jP/X3h2jVhFFcRj//rEQkuBrlBCwsUmdUsgCUsQVWGcV4hICwQWY0iZd1pBo6wpsDOiDYClocyzuhBDyQPI0TG7m+zUDc6c4DANzz70z58AB8GzM4Dq0Mnw2ukZrNTUDftAWg7upFWBCqF5tALvcrOAU4OPNy/UX8yTbVfUZYNgpfAUcAa5oL+d3ktWq+kmbeAOQZEYr4qFbGCYwh0mOh+Mc32H/xHt6J2a03ZYAlWSzqr4lWcfFtWXsA++SvAUugE9JvtJqBuyPGlm/rj2Hwz9uJ8DJ8J+mbueyk8AjrjoJfAFe0lEnAT8ZVZeSvKdVbDtdMPahql6PEFa3kjyn7Wh9XzC2U1VnI4TVtSSPq+rXgvNPgc3LnlpaTpI9YKeq3owdy0PhPb07w0R7o5eKg/dNkifAC9qCxXlVzUcOqVtJtoYWXfpPHkInARNCSZIkSZooG9NLkiRJ0kSZEEqSJEnSRJkQSpIkSdJEmRBKkiRJ0kSZEEqSJEnSRP0BenH04M8YoK4AAAAASUVORK5CYII=\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": "a0e485c6-7089-4ed7-d431-5b6e1eb4f37c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4/4 [==============================] - 0s 12ms/step - loss: 4.0531e-07 - 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": "01e6db08-daac-4a17-c063-b7c8bd3a8e7a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "313/313 [==============================] - 1s 3ms/step - loss: 2.8434 - accuracy: 0.6983\n",
            "Test Accuracy: 69.83%\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": "4c9c40a1-51f8-405b-878c-a75fdf1f8e2a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/30\n",
            "4/4 [==============================] - 0s 21ms/step - loss: 2.3116 - accuracy: 0.1000\n",
            "Epoch 2/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 2.2220 - accuracy: 0.2800\n",
            "Epoch 3/30\n",
            "4/4 [==============================] - 0s 5ms/step - loss: 2.1719 - accuracy: 0.3800\n",
            "Epoch 4/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 2.0847 - accuracy: 0.4500\n",
            "Epoch 5/30\n",
            "4/4 [==============================] - 0s 5ms/step - loss: 1.9582 - accuracy: 0.4800\n",
            "Epoch 6/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 1.7585 - accuracy: 0.4800\n",
            "Epoch 7/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 1.5881 - accuracy: 0.5900\n",
            "Epoch 8/30\n",
            "4/4 [==============================] - 0s 5ms/step - loss: 1.2891 - accuracy: 0.7200\n",
            "Epoch 9/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 1.0220 - accuracy: 0.7900\n",
            "Epoch 10/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.8842 - accuracy: 0.7500\n",
            "Epoch 11/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.6221 - accuracy: 0.8500\n",
            "Epoch 12/30\n",
            "4/4 [==============================] - 0s 5ms/step - loss: 0.4727 - accuracy: 0.9000\n",
            "Epoch 13/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.4455 - accuracy: 0.8600\n",
            "Epoch 14/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.3205 - accuracy: 0.9100\n",
            "Epoch 15/30\n",
            "4/4 [==============================] - 0s 6ms/step - loss: 0.2932 - accuracy: 0.9200\n",
            "Epoch 16/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.2600 - accuracy: 0.9000\n",
            "Epoch 17/30\n",
            "4/4 [==============================] - 0s 7ms/step - loss: 0.2220 - accuracy: 0.9200\n",
            "Epoch 18/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.1666 - accuracy: 0.9400\n",
            "Epoch 19/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.1059 - accuracy: 0.9700\n",
            "Epoch 20/30\n",
            "4/4 [==============================] - 0s 5ms/step - loss: 0.1034 - accuracy: 0.9800\n",
            "Epoch 21/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.1169 - accuracy: 0.9800\n",
            "Epoch 22/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.1007 - accuracy: 0.9800\n",
            "Epoch 23/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.0797 - accuracy: 0.9800\n",
            "Epoch 24/30\n",
            "4/4 [==============================] - 0s 5ms/step - loss: 0.0599 - accuracy: 0.9900\n",
            "Epoch 25/30\n",
            "4/4 [==============================] - 0s 5ms/step - loss: 0.0794 - accuracy: 0.9800\n",
            "Epoch 26/30\n",
            "4/4 [==============================] - 0s 6ms/step - loss: 0.0549 - accuracy: 0.9900\n",
            "Epoch 27/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.0452 - accuracy: 0.9900\n",
            "Epoch 28/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.0630 - accuracy: 0.9800\n",
            "Epoch 29/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.0545 - accuracy: 0.9900\n",
            "Epoch 30/30\n",
            "4/4 [==============================] - 0s 4ms/step - loss: 0.0275 - 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": "9e4804c4-a9ae-46b2-ed2c-48aa7f745f37"
      },
      "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": "e8a6a74f-850d-4554-a23f-fe12d998de87"
      },
      "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": "cc0298d6-58c0-4244-fe44-1ed5e5a02d24"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4/4 [==============================] - 0s 4ms/step - loss: 0.0299 - accuracy: 0.9900\n",
            "Training Accuracy: 99.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": "87cd088c-06e5-4b03-8b7d-9529bba172c3"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "313/313 [==============================] - 1s 3ms/step - loss: 1.3543 - accuracy: 0.6631\n",
            "Test Accuracy: 66.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_without_Unsupervised)",
      "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
}