Image Generation via Generative Adversarial Networks.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K29I-OwCEYzW",
        "outputId": "db8b297c-a4b8-457a-b43f-7570135306c7"
      },
      "source": [
        "# Image Generation via Generative Adversarial Networks"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "hyper parameters"
      ],
      "metadata": {
        "id": "Gwd8PDMe24Wh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "size_minibatch  = 10\n",
        "dim_latent      = 64\n",
        "learning_rate = 0.001\n",
        "number_epoch    = 300\n",
        "relu_ths=0.2"
      ],
      "metadata": {
        "id": "yvjO_c-723yQ"
      },
      "execution_count": 53,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kb2U7til2ymw"
      },
      "source": [
        "## import libraries"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "id": "Y3FZp-NU2ymw"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import torchvision\n",
        "from torch.utils.data import Dataset\n",
        "from os import listdir\n",
        "from os.path import join\n",
        "from torchvision import datasets, transforms\n",
        "from torch.utils.data import DataLoader\n",
        "from PIL import Image\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim\n",
        "from math import log10\n",
        "from tqdm import tqdm\n",
        "import os"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G-8xt7WO2ymx"
      },
      "source": [
        "## load data"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "%cd /content/drive/MyDrive/Colab Notebooks/MachineLearning2022-2/MachineLearning2022-2"
      ],
      "metadata": {
        "id": "rpbmr_1s2z4E",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6e38ee1d-273e-4c47-ba9e-8213adc57cad"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n",
            "/content/drive/MyDrive/Colab Notebooks/MachineLearning2022-2/MachineLearning2022-2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "id": "Y5sPRXpx2ymy"
      },
      "outputs": [],
      "source": [
        "directory_data  = '/content/drive/MyDrive/Colab Notebooks/MachineLearning2022-2/MachineLearning2022-2/'\n",
        "filename_data   = 'assignment_12_data.npz'\n",
        "data            = np.load(os.path.join(directory_data, filename_data))\n",
        "real            = data['real_images']"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "id": "tvP5VMnp2ymy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4019357e-60e7-44b3-fcc0-84db07af7244"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "size of real data: (4324, 32, 32)\n"
          ]
        }
      ],
      "source": [
        "print('size of real data:', real.shape)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T93gUi3U2ymz"
      },
      "source": [
        "## plot data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "id": "Nj0C2x-Z2ymz"
      },
      "outputs": [],
      "source": [
        "def plot_image(title, image):\n",
        "    \n",
        "    nRow = 3\n",
        "    nCol = 4\n",
        "    size = 3\n",
        "    \n",
        "    fig, axes = plt.subplots(nRow, nCol, figsize=(size * nCol, size * nRow))\n",
        "    fig.suptitle(title, fontsize=16)\n",
        "   \n",
        "    for r in range(nRow): \n",
        "        for c in range(nCol):\n",
        "            k = c * 300 + r * nCol * 300\n",
        "            axes[r, c].imshow(image[k], cmap='gray')\n",
        "\n",
        "    plt.tight_layout()\n",
        "    plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "id": "gNURVfIg2ym0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 657
        },
        "outputId": "f2768e00-54d6-4604-ba3d-c8dfa94f55cf"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 864x648 with 12 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "plot_image('training data', real)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7xd5KsKv2ym0"
      },
      "source": [
        "## custom data loader for the PyTorch framework"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "id": "9LRhHGW92ym0"
      },
      "outputs": [],
      "source": [
        "class dataset(Dataset):\n",
        "    \n",
        "    def __init__(self, image):\n",
        "        \n",
        "        self.image = image\n",
        "    \n",
        "    def __getitem__(self, index):\n",
        "        \n",
        "        sample  = self.image[index]\n",
        "        sample  = torch.FloatTensor(sample).unsqueeze(dim=0)\n",
        "\n",
        "        return (sample)\n",
        "    \n",
        "    def __len__(self):\n",
        "\n",
        "        number_image = len(self.image)\n",
        "\n",
        "        return (number_image)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X6UW7cBD2ym1"
      },
      "source": [
        "## setting device"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {
        "id": "d_IwBI3m2ym1"
      },
      "outputs": [],
      "source": [
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "metadata": {
        "id": "eYo03LET2ym1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c4bd6cba-0e12-42a0-ec1a-c6399f9c8ab2"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "cuda\n"
          ]
        }
      ],
      "source": [
        "print(device)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C4XfPo8y2ym1"
      },
      "source": [
        "## construct datasets and dataloaders "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "metadata": {
        "id": "3jNAR85s2ym2"
      },
      "outputs": [],
      "source": [
        "dataset_real    = dataset(real)\n",
        "dataloader_real = torch.utils.data.DataLoader(dataset_real, batch_size=size_minibatch, shuffle=True, drop_last=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "grQTgLcP2ym2"
      },
      "source": [
        "## neural networks "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 51,
      "metadata": {
        "id": "TcKjl0sq2ym2"
      },
      "outputs": [],
      "source": [
        "class Discriminator(nn.Module): \n",
        "\n",
        "\tdef __init__(self):\n",
        "        \n",
        "\t\tsuper(Discriminator, self).__init__()\n",
        "\t\tself.decoder = nn.Sequential(\n",
        "\t\t\tnn.Conv2d(1, 8, kernel_size=3, stride=2, padding=1, bias=True),\n",
        "\t\t\tnn.LeakyReLU(relu_ths, inplace=True),\t\t\t\n",
        "\t\t\t\n",
        "\t\t\tnn.Conv2d(8, 16, kernel_size=3, stride=2, padding=1, bias=True),\n",
        "\t\t\tnn.LeakyReLU(relu_ths, inplace=True),\t\t\t\n",
        "\t\t\t\n",
        "\t\t\tnn.Conv2d(16, 32, kernel_size=3, stride=2, padding=1, bias=True),\n",
        "\t\t\tnn.LeakyReLU(relu_ths, inplace=True),\t\t\t\n",
        "\t\t\t\n",
        "\t\t\tnn.Conv2d(32, 64, kernel_size=3, stride=2, padding=1, bias=True),\n",
        "\t\t\tnn.LeakyReLU(relu_ths, inplace=True),\t\t\t\n",
        "\t\t\t\n",
        "\t\t\tnn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1, bias=True),\n",
        "\t\t\tnn.LeakyReLU(relu_ths, inplace=True),\t\t\t\n",
        "\t\t)\t\n",
        "\t\t\n",
        "\t\tself.classifier = nn.Sequential(\n",
        "\t\t\tnn.Linear(128, 64, bias=True),\n",
        "\t\t\tnn.LeakyReLU(relu_ths, inplace=True),\t\n",
        "\n",
        "\t\t\tnn.Linear(64, 32, bias=True),\n",
        "\t\t\tnn.LeakyReLU(relu_ths, inplace=True),\t\n",
        "\n",
        "\t\t\tnn.Linear(32, 16, bias=True),\n",
        "\t\t\tnn.LeakyReLU(relu_ths, inplace=True),\t\n",
        "\n",
        "\t\t\tnn.Linear(16, 8, bias=True),\n",
        "\t\t\tnn.LeakyReLU(relu_ths, inplace=True),\t\n",
        "\n",
        "\t\t\tnn.Linear(8, 1, bias=True),\n",
        "\t\t) \n",
        "\n",
        "\t\tself.network = nn.Sequential(\n",
        "\t\t\tself.decoder,\n",
        "\t\t\tnn.Flatten(),\n",
        "\t\t\tself.classifier,\n",
        "\t\t)\n",
        "\n",
        "\t\tself.initialize_weight()\n",
        "\n",
        "\tdef forward(self, x):\n",
        "\t\ty = self.network.forward(x)\n",
        "\t\treturn y\n",
        "\n",
        "\tdef initialize_weight(self):\n",
        "\t\tpass"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 52,
      "metadata": {
        "id": "FW5IejVn2ym2"
      },
      "outputs": [],
      "source": [
        "class Generator(nn.Module): \n",
        "\n",
        "\tdef __init__(self):\n",
        "\t\tsuper(Generator, self).__init__()\n",
        "\n",
        "\t\tself.network = nn.Sequential(\n",
        "\t\t\tnn.Upsample(scale_factor=2, mode='bilinear', align_corners=False),\n",
        "\t\t\tnn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1, bias=True),\n",
        "\t\t\tnn.BatchNorm2d(64),\n",
        "\t\t\tnn.LeakyReLU(relu_ths, inplace=True),\n",
        "\t\t\t\n",
        "\t\t\tnn.Upsample(scale_factor=2, mode='bilinear', align_corners=False),\n",
        "\t\t\tnn.Conv2d(64, 32, kernel_size=3, stride=1, padding=1, bias=True),\n",
        "\t\t\tnn.BatchNorm2d(32),\n",
        "\t\t\tnn.LeakyReLU(relu_ths, inplace=True),\n",
        "\t\t\t\n",
        "\t\t\tnn.Upsample(scale_factor=2, mode='bilinear', align_corners=False),\n",
        "\t\t\tnn.Conv2d(32, 16, kernel_size=3, stride=1, padding=1, bias=True),\n",
        "\t\t\tnn.BatchNorm2d(16),\n",
        "\t\t\tnn.LeakyReLU(relu_ths, inplace=True),\n",
        "\t\t\t\n",
        "\t\t\tnn.Upsample(scale_factor=2, mode='bilinear', align_corners=False),\n",
        "\t\t\tnn.Conv2d(16, 8, kernel_size=3, stride=1, padding=1, bias=True),\n",
        "\t\t\tnn.BatchNorm2d(8),\n",
        "\t\t\tnn.LeakyReLU(relu_ths, inplace=True),\n",
        "\t\t\t\n",
        "\t\t\tnn.Upsample(scale_factor=2, mode='bilinear', align_corners=False),\n",
        "\t\t\tnn.Conv2d(8, 1, kernel_size=3, stride=1, padding=1, bias=True),\n",
        "\t\t\tnn.BatchNorm2d(1),\n",
        "\t\t\t\n",
        "\t\t\tnn.Sigmoid(),\n",
        "\t\t) \t\t\t\n",
        "\n",
        "\t\tself.initialize_weight()\n",
        "\t\t\n",
        "\tdef forward(self, x):\n",
        "\t\ty = self.network.forward(x)\n",
        "\t\treturn y\n",
        "\n",
        "\tdef initialize_weight(self):\n",
        "\t\tpass"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tPPVR5Rg2ym2"
      },
      "source": [
        "## build network"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 41,
      "metadata": {
        "id": "Vg32tkbT2ym2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "73998c8c-5448-4f5b-e5f0-84eb08a7e6da"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "initialize model parameters : xavier_uniform\n",
            "initialize model parameters : xavier_uniform\n"
          ]
        }
      ],
      "source": [
        "generator       = Generator().to(device)\n",
        "discriminator   = Discriminator().to(device)\n",
        "\n",
        "optimizer_generator = torch.optim.SGD(generator.parameters(), lr=learning_rate)\n",
        "optimizer_discriminator = torch.optim.SGD(discriminator.parameters(), lr=learning_rate)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##compute the loss"
      ],
      "metadata": {
        "id": "N8-owP7d4fyq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def compute_loss_discriminator(generator, discriminator, latent, real):\n",
        "    fake       = compute_prediction(generator, latent)\n",
        "    prediction_real = compute_prediction(discriminator, real)\n",
        "    prediction_fake = compute_prediction(discriminator, fake)\n",
        "    criterion   = nn.BCEWithLogitsLoss() \n",
        "    label_real  = torch.ones_like(prediction_real)\n",
        "    label_fake  = torch.zeros_like(prediction_fake)\n",
        "    loss_real = criterion(prediction_real, label_real)\n",
        "    loss_fake = criterion(prediction_fake, label_fake)\n",
        "    loss_discriminator = (loss_real + loss_fake) / 2.0\n",
        "\n",
        "    return loss_discriminator"
      ],
      "metadata": {
        "id": "PyOn20Wk4fL4"
      },
      "execution_count": 56,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def compute_loss_generator(generator, discriminator, latent):\n",
        "    fake       = compute_prediction(generator, latent)\n",
        "    prediction_fake = compute_prediction(discriminator, fake)\n",
        "    criterion       = nn.BCEWithLogitsLoss()\n",
        "    label_real      = torch.ones_like(prediction_fake)\n",
        "    loss_generator  = criterion(prediction_fake, label_real)\n",
        "\n",
        "    return loss_generator"
      ],
      "metadata": {
        "id": "tsoTAsi64iHB"
      },
      "execution_count": 57,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Kwk3Y8uX2ym3"
      },
      "source": [
        "## compute the prediction"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 44,
      "metadata": {
        "id": "k1jSMUQ12ym3"
      },
      "outputs": [],
      "source": [
        "def compute_prediction(model, input):\n",
        "\n",
        "    prediction = model(input)\n",
        "\n",
        "    return prediction"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bMqtOi822ym3"
      },
      "source": [
        "## compute the accuracy"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 45,
      "metadata": {
        "id": "WG5aA8B42ym3"
      },
      "outputs": [],
      "source": [
        "def compute_bounding_mask(prediction_binary):\n",
        "    \n",
        "    bounding_mask = torch.zeros_like(prediction_binary)\n",
        "    \n",
        "    for i in range(prediction_binary.shape[0]):\n",
        "        prediction = prediction_binary[i]\n",
        "        \n",
        "        #(idx_row, idx_col) = torch.nonzero(prediction, as_tuple=True)\n",
        "        idx_row = torch.nonzero(prediction, as_tuple=True)[0]\n",
        "        idx_col = torch.nonzero(prediction, as_tuple=True)[1]\n",
        "        \n",
        "        if len(idx_row) > 0: \n",
        "            idx_row_min = idx_row.min()\n",
        "            idx_row_max = idx_row.max()\n",
        "        \n",
        "            idx_col_min = idx_col.min()\n",
        "            idx_col_max = idx_col.max()\n",
        "    \n",
        "            bounding_mask[i, idx_row_min:idx_row_max+1, idx_col_min:idx_col_max+1] = 1 \n",
        "        \n",
        "    return bounding_mask"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 47,
      "metadata": {
        "id": "vftkreVs2ym3"
      },
      "outputs": [],
      "source": [
        "def compute_accuracy(prediction):\n",
        "\n",
        "    binary      = (prediction >= 0.5)\n",
        "    mask        = compute_bounding_mask(binary)\n",
        "    \n",
        "    intersection = (binary & mask).float().sum((1, 2))\n",
        "    union        = (binary | mask).float().sum((1, 2))\n",
        "\n",
        "    eps         = 1e-8\n",
        "    correct     = (intersection + eps) / (union + eps)\n",
        "    accuracy    = correct.mean() * 100.0\n",
        "    accuracy    = accuracy.cpu() \n",
        "    \n",
        "    return accuracy"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vW4KCOaY2ym4"
      },
      "source": [
        "## train"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 48,
      "metadata": {
        "id": "61eZW5h22ym4"
      },
      "outputs": [],
      "source": [
        "def train(generator, discriminator, dataloader):\n",
        "    \n",
        "    for index_batch, (real) in enumerate(dataloader):\n",
        "        real        = real.to(device)\n",
        "        size_batch  = len(real)\n",
        "        latent      = torch.randn(size_batch, dim_latent, device=device)\n",
        "        latent      = torch.reshape(latent, [size_batch, dim_latent, 1, 1])\n",
        "\n",
        "        # ---------------------------------------------------------------------------\n",
        "        #  \n",
        "        # update the generator\n",
        "        #  \n",
        "        # ---------------------------------------------------------------------------\n",
        "        generator.train()\n",
        "        discriminator.eval()\n",
        "\n",
        "        optimizer_generator.zero_grad()\n",
        "        loss_generator = compute_loss_generator(generator, discriminator, latent)\n",
        "        loss_generator.backward()\n",
        "        optimizer_generator.step()\n",
        "\n",
        "        # ---------------------------------------------------------------------------\n",
        "        #  \n",
        "        # update the discriminator\n",
        "        #  \n",
        "        # ---------------------------------------------------------------------------\n",
        "        generator.eval()\n",
        "        discriminator.train()\n",
        "\n",
        "        optimizer_discriminator.zero_grad()\n",
        "        #\n",
        "        loss_discriminator = compute_loss_discriminator(generator, discriminator, latent, real)\n",
        "        loss_discriminator.backward()\n",
        "        optimizer_discriminator.step()\n",
        "        \n",
        "        data_fake   = compute_prediction(generator, latent)\n",
        "        accuracy    = compute_accuracy(data_fake)\n",
        "        "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zLXRL55b2ym4"
      },
      "source": [
        "## test"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 49,
      "metadata": {
        "id": "dgmJjJTo2ym4"
      },
      "outputs": [],
      "source": [
        "def test(generator, latent):\n",
        "    \n",
        "    generator.eval()\n",
        "    \n",
        "    prediction  = generator(latent)\n",
        "    prediction  = prediction.squeeze(axis=1)\n",
        "    accuracy    = compute_accuracy(prediction)\n",
        "    \n",
        "    return accuracy"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "37B2Iha_2ym4"
      },
      "source": [
        "## training epoch"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PRz2tLny2ym4",
        "outputId": "c952d0af-02a1-45bc-d619-fe605267b8a9"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 300/300 [43:15<00:00,  8.65s/it]\n"
          ]
        }
      ],
      "source": [
        "\n",
        "accuracy_epoch  = np.zeros(number_epoch)\n",
        "\n",
        "num_latent_test = 100\n",
        "latent_test = torch.randn(num_latent_test, dim_latent, device=device)\n",
        "latent_test = torch.reshape(latent_test, [num_latent_test, dim_latent, 1, 1])\n",
        "\n",
        "for i in tqdm(range(number_epoch)):\n",
        "    train(generator, discriminator, dataloader_real)\n",
        "    accuracy = test(generator, latent_test)\n",
        "    accuracy_epoch[i] = accuracy"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZrFZraBg2ym4"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vM31ZyZD2ym5"
      },
      "source": [
        "# functions for presenting the results"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mOs86oDx2ym5"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "id": "S2i00mI92ym5"
      },
      "outputs": [],
      "source": [
        "def function_result_01():\n",
        "\n",
        "    num_latent_visualize = 16\n",
        "\n",
        "    latent_visualize = torch.randn(num_latent_visualize, dim_latent, device=device)\n",
        "    latent_visualize = torch.reshape(latent_visualize, [num_latent_visualize, dim_latent, 1, 1]) \n",
        "\n",
        "    prediction = compute_prediction(generator, latent_visualize)\n",
        "    prediction = prediction.squeeze(axis=1)\n",
        "    prediction_binary = (prediction >= 0.5)\n",
        "    bounding_mask = compute_bounding_mask(prediction_binary)\n",
        "        \n",
        "    fake = prediction.detach().cpu()\n",
        "    mask = bounding_mask.detach().cpu()\n",
        "\n",
        "    nRow = 4\n",
        "    nCol = 4 \n",
        "    size = 3 \n",
        "    \n",
        "    title = 'fake image'\n",
        "    fig, axes = plt.subplots(nRow, nCol, figsize=(size * nCol, size * nRow))\n",
        "    fig.suptitle(title, fontsize=16)\n",
        "\n",
        "    for r in range(nRow): \n",
        "        for c in range(nCol):\n",
        "            k = c + r * nCol\n",
        "            axes[r, c].imshow(fake[k], cmap='gray', vmin=0, vmax=1)\n",
        "            axes[r, c].xaxis.set_visible(False)\n",
        "            axes[r, c].yaxis.set_visible(False)\n",
        "\n",
        "    plt.tight_layout()\n",
        "    plt.show()\n",
        "    \n",
        "    title = 'bounding mask'\n",
        "    fig, axes = plt.subplots(nRow, nCol, figsize=(size * nCol, size * nRow))\n",
        "    fig.suptitle(title, fontsize=16)\n",
        "\n",
        "    for r in range(nRow): \n",
        "        for c in range(nCol):\n",
        "            k = c + r * nCol\n",
        "            axes[r, c].imshow(mask[k], cmap='gray', vmin=0, vmax=1)\n",
        "            axes[r, c].xaxis.set_visible(False)\n",
        "            axes[r, c].yaxis.set_visible(False)\n",
        "                        \n",
        "    plt.tight_layout()\n",
        "    plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "id": "otTgFkZe2ym5"
      },
      "outputs": [],
      "source": [
        "def function_result_02():\n",
        "\n",
        "    title           = 'accuracy'\n",
        "    label_axis_x    = 'epoch' \n",
        "    label_axis_y    = 'accuracy'\n",
        "    \n",
        "    plt.figure(figsize=(8, 6))\n",
        "    plt.title(title)\n",
        "    \n",
        "    plt.plot(accuracy_epoch)\n",
        "    \n",
        "    plt.xlabel(label_axis_x)\n",
        "    plt.ylabel(label_axis_y)\n",
        "\n",
        "    plt.tight_layout()\n",
        "    plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "id": "7FzakjWZ2ym5"
      },
      "outputs": [],
      "source": [
        "def function_result_03():\n",
        "\n",
        "    print('final accuracy = %9.8f' % (accuracy_epoch[-1]))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-zAnOaYP2ym5"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n9spxJjy2ym5"
      },
      "source": [
        "## results"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zs9n19TF2ym6"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "id": "eWuVBgh02ym6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "f27e6643-fda4-4a8c-ca83-7ee89d7d7c5d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "################################################################################\n",
            "#\n",
            "# RESULT # 01\n",
            "#\n",
            "################################################################################\n",
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 864x864 with 16 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 864x864 with 16 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "################################################################################\n",
            "#\n",
            "# RESULT # 02\n",
            "#\n",
            "################################################################################\n",
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 576x432 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "################################################################################\n",
            "#\n",
            "# RESULT # 03\n",
            "#\n",
            "################################################################################\n",
            "\n",
            "final accuracy = 92.72616577\n"
          ]
        }
      ],
      "source": [
        "number_result = 3\n",
        "\n",
        "for i in range(number_result):\n",
        "\n",
        "    title           = '# RESULT # {:02d}'.format(i+1) \n",
        "    name_function   = 'function_result_{:02d}()'.format(i+1)\n",
        "\n",
        "    print('') \n",
        "    print('################################################################################')\n",
        "    print('#') \n",
        "    print(title)\n",
        "    print('#') \n",
        "    print('################################################################################')\n",
        "    print('') \n",
        "\n",
        "    eval(name_function)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!apt-get update"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lbprRGXLujzl",
        "outputId": "24c60305-1ce5-4dda-8c5c-6a4c9121d806"
      },
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Get:1 https://cloud.r-project.org/bin/linux/ubuntu bionic-cran40/ InRelease [3,626 B]\n",
            "Ign:2 https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64  InRelease\n",
            "Get:3 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64  InRelease [1,581 B]\n",
            "Hit:4 https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64  Release\n",
            "Hit:5 http://ppa.launchpad.net/c2d4u.team/c2d4u4.0+/ubuntu bionic InRelease\n",
            "Get:6 http://security.ubuntu.com/ubuntu bionic-security InRelease [88.7 kB]\n",
            "Hit:7 http://archive.ubuntu.com/ubuntu bionic InRelease\n",
            "Get:8 http://archive.ubuntu.com/ubuntu bionic-updates InRelease [88.7 kB]\n",
            "Get:9 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64  Packages [1,073 kB]\n",
            "Hit:10 http://ppa.launchpad.net/cran/libgit2/ubuntu bionic InRelease\n",
            "Hit:12 http://ppa.launchpad.net/deadsnakes/ppa/ubuntu bionic InRelease\n",
            "Get:13 http://archive.ubuntu.com/ubuntu bionic-backports InRelease [83.3 kB]\n",
            "Hit:14 http://ppa.launchpad.net/graphics-drivers/ppa/ubuntu bionic InRelease\n",
            "Get:15 http://security.ubuntu.com/ubuntu bionic-security/main amd64 Packages [3,099 kB]\n",
            "Get:16 http://archive.ubuntu.com/ubuntu bionic-updates/restricted amd64 Packages [1,352 kB]\n",
            "Get:17 http://security.ubuntu.com/ubuntu bionic-security/restricted amd64 Packages [1,311 kB]\n",
            "Get:18 http://security.ubuntu.com/ubuntu bionic-security/universe amd64 Packages [1,567 kB]\n",
            "Get:19 http://archive.ubuntu.com/ubuntu bionic-updates/main amd64 Packages [3,524 kB]\n",
            "Get:20 http://archive.ubuntu.com/ubuntu bionic-updates/universe amd64 Packages [2,342 kB]\n",
            "Fetched 14.5 MB in 3s (4,873 kB/s)\n",
            "Reading package lists... Done\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!apt-get install texlive texlive-xetex texlive-latex-extra pandoc\n",
        "!pip install pypandoc"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OOdBrEQHunUf",
        "outputId": "3b6b8fc7-05d0-40f4-d4b3-71944b0eebbe"
      },
      "execution_count": 59,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Reading package lists... Done\n",
            "Building dependency tree       \n",
            "Reading state information... Done\n",
            "pandoc is already the newest version (1.19.2.4~dfsg-1build4).\n",
            "pandoc set to manually installed.\n",
            "The following package was automatically installed and is no longer required:\n",
            "  libnvidia-common-460\n",
            "Use 'apt autoremove' to remove it.\n",
            "The following additional packages will be installed:\n",
            "  fonts-droid-fallback fonts-lato fonts-lmodern fonts-noto-mono fonts-texgyre\n",
            "  javascript-common libcupsfilters1 libcupsimage2 libgs9 libgs9-common\n",
            "  libijs-0.35 libjbig2dec0 libjs-jquery libkpathsea6 libpotrace0 libptexenc1\n",
            "  libruby2.5 libsynctex1 libtexlua52 libtexluajit2 libzzip-0-13 lmodern\n",
            "  poppler-data preview-latex-style rake ruby ruby-did-you-mean ruby-minitest\n",
            "  ruby-net-telnet ruby-power-assert ruby-test-unit ruby2.5\n",
            "  rubygems-integration t1utils tex-common tex-gyre texlive-base\n",
            "  texlive-binaries texlive-fonts-recommended texlive-latex-base\n",
            "  texlive-latex-recommended texlive-pictures texlive-plain-generic tipa\n",
            "Suggested packages:\n",
            "  fonts-noto apache2 | lighttpd | httpd poppler-utils ghostscript\n",
            "  fonts-japanese-mincho | fonts-ipafont-mincho fonts-japanese-gothic\n",
            "  | fonts-ipafont-gothic fonts-arphic-ukai fonts-arphic-uming fonts-nanum ri\n",
            "  ruby-dev bundler debhelper gv | postscript-viewer perl-tk xpdf-reader\n",
            "  | pdf-viewer texlive-fonts-recommended-doc texlive-latex-base-doc\n",
            "  python-pygments icc-profiles libfile-which-perl\n",
            "  libspreadsheet-parseexcel-perl texlive-latex-extra-doc\n",
            "  texlive-latex-recommended-doc texlive-pstricks dot2tex prerex ruby-tcltk\n",
            "  | libtcltk-ruby texlive-pictures-doc vprerex\n",
            "The following NEW packages will be installed:\n",
            "  fonts-droid-fallback fonts-lato fonts-lmodern fonts-noto-mono fonts-texgyre\n",
            "  javascript-common libcupsfilters1 libcupsimage2 libgs9 libgs9-common\n",
            "  libijs-0.35 libjbig2dec0 libjs-jquery libkpathsea6 libpotrace0 libptexenc1\n",
            "  libruby2.5 libsynctex1 libtexlua52 libtexluajit2 libzzip-0-13 lmodern\n",
            "  poppler-data preview-latex-style rake ruby ruby-did-you-mean ruby-minitest\n",
            "  ruby-net-telnet ruby-power-assert ruby-test-unit ruby2.5\n",
            "  rubygems-integration t1utils tex-common tex-gyre texlive texlive-base\n",
            "  texlive-binaries texlive-fonts-recommended texlive-latex-base\n",
            "  texlive-latex-extra texlive-latex-recommended texlive-pictures\n",
            "  texlive-plain-generic texlive-xetex tipa\n",
            "0 upgraded, 47 newly installed, 0 to remove and 34 not upgraded.\n",
            "Need to get 146 MB of archives.\n",
            "After this operation, 460 MB of additional disk space will be used.\n",
            "Get:1 http://archive.ubuntu.com/ubuntu bionic/main amd64 fonts-droid-fallback all 1:6.0.1r16-1.1 [1,805 kB]\n",
            "Get:2 http://archive.ubuntu.com/ubuntu bionic/main amd64 fonts-lato all 2.0-2 [2,698 kB]\n",
            "Get:3 http://archive.ubuntu.com/ubuntu bionic/main amd64 poppler-data all 0.4.8-2 [1,479 kB]\n",
            "Get:4 http://archive.ubuntu.com/ubuntu bionic/main amd64 tex-common all 6.09 [33.0 kB]\n",
            "Get:5 http://archive.ubuntu.com/ubuntu bionic/main amd64 fonts-lmodern all 2.004.5-3 [4,551 kB]\n",
            "Get:6 http://archive.ubuntu.com/ubuntu bionic/main amd64 fonts-noto-mono all 20171026-2 [75.5 kB]\n",
            "Get:7 http://archive.ubuntu.com/ubuntu bionic/universe amd64 fonts-texgyre all 20160520-1 [8,761 kB]\n",
            "Get:8 http://archive.ubuntu.com/ubuntu bionic/main amd64 javascript-common all 11 [6,066 B]\n",
            "Get:9 http://archive.ubuntu.com/ubuntu bionic-updates/main amd64 libcupsfilters1 amd64 1.20.2-0ubuntu3.1 [108 kB]\n",
            "Get:10 http://archive.ubuntu.com/ubuntu bionic-updates/main amd64 libcupsimage2 amd64 2.2.7-1ubuntu2.9 [18.6 kB]\n",
            "Get:11 http://archive.ubuntu.com/ubuntu bionic/main amd64 libijs-0.35 amd64 0.35-13 [15.5 kB]\n",
            "Get:12 http://archive.ubuntu.com/ubuntu bionic/main amd64 libjbig2dec0 amd64 0.13-6 [55.9 kB]\n",
            "Get:13 http://archive.ubuntu.com/ubuntu bionic-updates/main amd64 libgs9-common all 9.26~dfsg+0-0ubuntu0.18.04.17 [5,092 kB]\n",
            "Get:14 http://archive.ubuntu.com/ubuntu bionic-updates/main amd64 libgs9 amd64 9.26~dfsg+0-0ubuntu0.18.04.17 [2,267 kB]\n",
            "Get:15 http://archive.ubuntu.com/ubuntu bionic/main amd64 libjs-jquery all 3.2.1-1 [152 kB]\n",
            "Get:16 http://archive.ubuntu.com/ubuntu bionic-updates/main amd64 libkpathsea6 amd64 2017.20170613.44572-8ubuntu0.1 [54.9 kB]\n",
            "Get:17 http://archive.ubuntu.com/ubuntu bionic/main amd64 libpotrace0 amd64 1.14-2 [17.4 kB]\n",
            "Get:18 http://archive.ubuntu.com/ubuntu bionic-updates/main amd64 libptexenc1 amd64 2017.20170613.44572-8ubuntu0.1 [34.5 kB]\n",
            "Get:19 http://archive.ubuntu.com/ubuntu bionic/main amd64 rubygems-integration all 1.11 [4,994 B]\n",
            "Get:20 http://archive.ubuntu.com/ubuntu bionic-updates/main amd64 ruby2.5 amd64 2.5.1-1ubuntu1.12 [48.6 kB]\n",
            "Get:21 http://archive.ubuntu.com/ubuntu bionic/main amd64 ruby amd64 1:2.5.1 [5,712 B]\n",
            "Get:22 http://archive.ubuntu.com/ubuntu bionic-updates/main amd64 rake all 12.3.1-1ubuntu0.1 [44.9 kB]\n",
            "Get:23 http://archive.ubuntu.com/ubuntu bionic/main amd64 ruby-did-you-mean all 1.2.0-2 [9,700 B]\n",
            "Get:24 http://archive.ubuntu.com/ubuntu bionic/main amd64 ruby-minitest all 5.10.3-1 [38.6 kB]\n",
            "Get:25 http://archive.ubuntu.com/ubuntu bionic/main amd64 ruby-net-telnet all 0.1.1-2 [12.6 kB]\n",
            "Get:26 http://archive.ubuntu.com/ubuntu bionic/main amd64 ruby-power-assert all 0.3.0-1 [7,952 B]\n",
            "Get:27 http://archive.ubuntu.com/ubuntu bionic/main amd64 ruby-test-unit all 3.2.5-1 [61.1 kB]\n",
            "Get:28 http://archive.ubuntu.com/ubuntu bionic-updates/main amd64 libruby2.5 amd64 2.5.1-1ubuntu1.12 [3,073 kB]\n",
            "Get:29 http://archive.ubuntu.com/ubuntu bionic-updates/main amd64 libsynctex1 amd64 2017.20170613.44572-8ubuntu0.1 [41.4 kB]\n",
            "Get:30 http://archive.ubuntu.com/ubuntu bionic-updates/main amd64 libtexlua52 amd64 2017.20170613.44572-8ubuntu0.1 [91.2 kB]\n",
            "Get:31 http://archive.ubuntu.com/ubuntu bionic-updates/main amd64 libtexluajit2 amd64 2017.20170613.44572-8ubuntu0.1 [230 kB]\n",
            "Get:32 http://archive.ubuntu.com/ubuntu bionic-updates/main amd64 libzzip-0-13 amd64 0.13.62-3.1ubuntu0.18.04.1 [26.0 kB]\n",
            "Get:33 http://archive.ubuntu.com/ubuntu bionic/main amd64 lmodern all 2.004.5-3 [9,631 kB]\n",
            "Get:34 http://archive.ubuntu.com/ubuntu bionic/main amd64 preview-latex-style all 11.91-1ubuntu1 [185 kB]\n",
            "Get:35 http://archive.ubuntu.com/ubuntu bionic/main amd64 t1utils amd64 1.41-2 [56.0 kB]\n",
            "Get:36 http://archive.ubuntu.com/ubuntu bionic/universe amd64 tex-gyre all 20160520-1 [4,998 kB]\n",
            "Get:37 http://archive.ubuntu.com/ubuntu bionic-updates/main amd64 texlive-binaries amd64 2017.20170613.44572-8ubuntu0.1 [8,179 kB]\n",
            "Get:38 http://archive.ubuntu.com/ubuntu bionic/main amd64 texlive-base all 2017.20180305-1 [18.7 MB]\n",
            "Get:39 http://archive.ubuntu.com/ubuntu bionic/universe amd64 texlive-fonts-recommended all 2017.20180305-1 [5,262 kB]\n",
            "Get:40 http://archive.ubuntu.com/ubuntu bionic/main amd64 texlive-latex-base all 2017.20180305-1 [951 kB]\n",
            "Get:41 http://archive.ubuntu.com/ubuntu bionic/main amd64 texlive-latex-recommended all 2017.20180305-1 [14.9 MB]\n",
            "Get:42 http://archive.ubuntu.com/ubuntu bionic/universe amd64 texlive all 2017.20180305-1 [14.4 kB]\n",
            "Get:43 http://archive.ubuntu.com/ubuntu bionic/universe amd64 texlive-pictures all 2017.20180305-1 [4,026 kB]\n",
            "Get:44 http://archive.ubuntu.com/ubuntu bionic/universe amd64 texlive-latex-extra all 2017.20180305-2 [10.6 MB]\n",
            "Get:45 http://archive.ubuntu.com/ubuntu bionic/universe amd64 texlive-plain-generic all 2017.20180305-2 [23.6 MB]\n",
            "Get:46 http://archive.ubuntu.com/ubuntu bionic/universe amd64 tipa all 2:1.3-20 [2,978 kB]\n",
            "Get:47 http://archive.ubuntu.com/ubuntu bionic/universe amd64 texlive-xetex all 2017.20180305-1 [10.7 MB]\n",
            "Fetched 146 MB in 7s (22.0 MB/s)\n",
            "Extracting templates from packages: 100%\n",
            "Preconfiguring packages ...\n",
            "Selecting previously unselected package fonts-droid-fallback.\n",
            "(Reading database ... 124013 files and directories currently installed.)\n",
            "Preparing to unpack .../00-fonts-droid-fallback_1%3a6.0.1r16-1.1_all.deb ...\n",
            "Unpacking fonts-droid-fallback (1:6.0.1r16-1.1) ...\n",
            "Selecting previously unselected package fonts-lato.\n",
            "Preparing to unpack .../01-fonts-lato_2.0-2_all.deb ...\n",
            "Unpacking fonts-lato (2.0-2) ...\n",
            "Selecting previously unselected package poppler-data.\n",
            "Preparing to unpack .../02-poppler-data_0.4.8-2_all.deb ...\n",
            "Unpacking poppler-data (0.4.8-2) ...\n",
            "Selecting previously unselected package tex-common.\n",
            "Preparing to unpack .../03-tex-common_6.09_all.deb ...\n",
            "Unpacking tex-common (6.09) ...\n",
            "Selecting previously unselected package fonts-lmodern.\n",
            "Preparing to unpack .../04-fonts-lmodern_2.004.5-3_all.deb ...\n",
            "Unpacking fonts-lmodern (2.004.5-3) ...\n",
            "Selecting previously unselected package fonts-noto-mono.\n",
            "Preparing to unpack .../05-fonts-noto-mono_20171026-2_all.deb ...\n",
            "Unpacking fonts-noto-mono (20171026-2) ...\n",
            "Selecting previously unselected package fonts-texgyre.\n",
            "Preparing to unpack .../06-fonts-texgyre_20160520-1_all.deb ...\n",
            "Unpacking fonts-texgyre (20160520-1) ...\n",
            "Selecting previously unselected package javascript-common.\n",
            "Preparing to unpack .../07-javascript-common_11_all.deb ...\n",
            "Unpacking javascript-common (11) ...\n",
            "Selecting previously unselected package libcupsfilters1:amd64.\n",
            "Preparing to unpack .../08-libcupsfilters1_1.20.2-0ubuntu3.1_amd64.deb ...\n",
            "Unpacking libcupsfilters1:amd64 (1.20.2-0ubuntu3.1) ...\n",
            "Selecting previously unselected package libcupsimage2:amd64.\n",
            "Preparing to unpack .../09-libcupsimage2_2.2.7-1ubuntu2.9_amd64.deb ...\n",
            "Unpacking libcupsimage2:amd64 (2.2.7-1ubuntu2.9) ...\n",
            "Selecting previously unselected package libijs-0.35:amd64.\n",
            "Preparing to unpack .../10-libijs-0.35_0.35-13_amd64.deb ...\n",
            "Unpacking libijs-0.35:amd64 (0.35-13) ...\n",
            "Selecting previously unselected package libjbig2dec0:amd64.\n",
            "Preparing to unpack .../11-libjbig2dec0_0.13-6_amd64.deb ...\n",
            "Unpacking libjbig2dec0:amd64 (0.13-6) ...\n",
            "Selecting previously unselected package libgs9-common.\n",
            "Preparing to unpack .../12-libgs9-common_9.26~dfsg+0-0ubuntu0.18.04.17_all.deb ...\n",
            "Unpacking libgs9-common (9.26~dfsg+0-0ubuntu0.18.04.17) ...\n",
            "Selecting previously unselected package libgs9:amd64.\n",
            "Preparing to unpack .../13-libgs9_9.26~dfsg+0-0ubuntu0.18.04.17_amd64.deb ...\n",
            "Unpacking libgs9:amd64 (9.26~dfsg+0-0ubuntu0.18.04.17) ...\n",
            "Selecting previously unselected package libjs-jquery.\n",
            "Preparing to unpack .../14-libjs-jquery_3.2.1-1_all.deb ...\n",
            "Unpacking libjs-jquery (3.2.1-1) ...\n",
            "Selecting previously unselected package libkpathsea6:amd64.\n",
            "Preparing to unpack .../15-libkpathsea6_2017.20170613.44572-8ubuntu0.1_amd64.deb ...\n",
            "Unpacking libkpathsea6:amd64 (2017.20170613.44572-8ubuntu0.1) ...\n",
            "Selecting previously unselected package libpotrace0.\n",
            "Preparing to unpack .../16-libpotrace0_1.14-2_amd64.deb ...\n",
            "Unpacking libpotrace0 (1.14-2) ...\n",
            "Selecting previously unselected package libptexenc1:amd64.\n",
            "Preparing to unpack .../17-libptexenc1_2017.20170613.44572-8ubuntu0.1_amd64.deb ...\n",
            "Unpacking libptexenc1:amd64 (2017.20170613.44572-8ubuntu0.1) ...\n",
            "Selecting previously unselected package rubygems-integration.\n",
            "Preparing to unpack .../18-rubygems-integration_1.11_all.deb ...\n",
            "Unpacking rubygems-integration (1.11) ...\n",
            "Selecting previously unselected package ruby2.5.\n",
            "Preparing to unpack .../19-ruby2.5_2.5.1-1ubuntu1.12_amd64.deb ...\n",
            "Unpacking ruby2.5 (2.5.1-1ubuntu1.12) ...\n",
            "Selecting previously unselected package ruby.\n",
            "Preparing to unpack .../20-ruby_1%3a2.5.1_amd64.deb ...\n",
            "Unpacking ruby (1:2.5.1) ...\n",
            "Selecting previously unselected package rake.\n",
            "Preparing to unpack .../21-rake_12.3.1-1ubuntu0.1_all.deb ...\n",
            "Unpacking rake (12.3.1-1ubuntu0.1) ...\n",
            "Selecting previously unselected package ruby-did-you-mean.\n",
            "Preparing to unpack .../22-ruby-did-you-mean_1.2.0-2_all.deb ...\n",
            "Unpacking ruby-did-you-mean (1.2.0-2) ...\n",
            "Selecting previously unselected package ruby-minitest.\n",
            "Preparing to unpack .../23-ruby-minitest_5.10.3-1_all.deb ...\n",
            "Unpacking ruby-minitest (5.10.3-1) ...\n",
            "Selecting previously unselected package ruby-net-telnet.\n",
            "Preparing to unpack .../24-ruby-net-telnet_0.1.1-2_all.deb ...\n",
            "Unpacking ruby-net-telnet (0.1.1-2) ...\n",
            "Selecting previously unselected package ruby-power-assert.\n",
            "Preparing to unpack .../25-ruby-power-assert_0.3.0-1_all.deb ...\n",
            "Unpacking ruby-power-assert (0.3.0-1) ...\n",
            "Selecting previously unselected package ruby-test-unit.\n",
            "Preparing to unpack .../26-ruby-test-unit_3.2.5-1_all.deb ...\n",
            "Unpacking ruby-test-unit (3.2.5-1) ...\n",
            "Selecting previously unselected package libruby2.5:amd64.\n",
            "Preparing to unpack .../27-libruby2.5_2.5.1-1ubuntu1.12_amd64.deb ...\n",
            "Unpacking libruby2.5:amd64 (2.5.1-1ubuntu1.12) ...\n",
            "Selecting previously unselected package libsynctex1:amd64.\n",
            "Preparing to unpack .../28-libsynctex1_2017.20170613.44572-8ubuntu0.1_amd64.deb ...\n",
            "Unpacking libsynctex1:amd64 (2017.20170613.44572-8ubuntu0.1) ...\n",
            "Selecting previously unselected package libtexlua52:amd64.\n",
            "Preparing to unpack .../29-libtexlua52_2017.20170613.44572-8ubuntu0.1_amd64.deb ...\n",
            "Unpacking libtexlua52:amd64 (2017.20170613.44572-8ubuntu0.1) ...\n",
            "Selecting previously unselected package libtexluajit2:amd64.\n",
            "Preparing to unpack .../30-libtexluajit2_2017.20170613.44572-8ubuntu0.1_amd64.deb ...\n",
            "Unpacking libtexluajit2:amd64 (2017.20170613.44572-8ubuntu0.1) ...\n",
            "Selecting previously unselected package libzzip-0-13:amd64.\n",
            "Preparing to unpack .../31-libzzip-0-13_0.13.62-3.1ubuntu0.18.04.1_amd64.deb ...\n",
            "Unpacking libzzip-0-13:amd64 (0.13.62-3.1ubuntu0.18.04.1) ...\n",
            "Selecting previously unselected package lmodern.\n",
            "Preparing to unpack .../32-lmodern_2.004.5-3_all.deb ...\n",
            "Unpacking lmodern (2.004.5-3) ...\n",
            "Selecting previously unselected package preview-latex-style.\n",
            "Preparing to unpack .../33-preview-latex-style_11.91-1ubuntu1_all.deb ...\n",
            "Unpacking preview-latex-style (11.91-1ubuntu1) ...\n",
            "Selecting previously unselected package t1utils.\n",
            "Preparing to unpack .../34-t1utils_1.41-2_amd64.deb ...\n",
            "Unpacking t1utils (1.41-2) ...\n",
            "Selecting previously unselected package tex-gyre.\n",
            "Preparing to unpack .../35-tex-gyre_20160520-1_all.deb ...\n",
            "Unpacking tex-gyre (20160520-1) ...\n",
            "Selecting previously unselected package texlive-binaries.\n",
            "Preparing to unpack .../36-texlive-binaries_2017.20170613.44572-8ubuntu0.1_amd64.deb ...\n",
            "Unpacking texlive-binaries (2017.20170613.44572-8ubuntu0.1) ...\n",
            "Selecting previously unselected package texlive-base.\n",
            "Preparing to unpack .../37-texlive-base_2017.20180305-1_all.deb ...\n",
            "Unpacking texlive-base (2017.20180305-1) ...\n",
            "Selecting previously unselected package texlive-fonts-recommended.\n",
            "Preparing to unpack .../38-texlive-fonts-recommended_2017.20180305-1_all.deb ...\n",
            "Unpacking texlive-fonts-recommended (2017.20180305-1) ...\n",
            "Selecting previously unselected package texlive-latex-base.\n",
            "Preparing to unpack .../39-texlive-latex-base_2017.20180305-1_all.deb ...\n",
            "Unpacking texlive-latex-base (2017.20180305-1) ...\n",
            "Selecting previously unselected package texlive-latex-recommended.\n",
            "Preparing to unpack .../40-texlive-latex-recommended_2017.20180305-1_all.deb ...\n",
            "Unpacking texlive-latex-recommended (2017.20180305-1) ...\n",
            "Selecting previously unselected package texlive.\n",
            "Preparing to unpack .../41-texlive_2017.20180305-1_all.deb ...\n",
            "Unpacking texlive (2017.20180305-1) ...\n",
            "Selecting previously unselected package texlive-pictures.\n",
            "Preparing to unpack .../42-texlive-pictures_2017.20180305-1_all.deb ...\n",
            "Unpacking texlive-pictures (2017.20180305-1) ...\n",
            "Selecting previously unselected package texlive-latex-extra.\n",
            "Preparing to unpack .../43-texlive-latex-extra_2017.20180305-2_all.deb ...\n",
            "Unpacking texlive-latex-extra (2017.20180305-2) ...\n",
            "Selecting previously unselected package texlive-plain-generic.\n",
            "Preparing to unpack .../44-texlive-plain-generic_2017.20180305-2_all.deb ...\n",
            "Unpacking texlive-plain-generic (2017.20180305-2) ...\n",
            "Selecting previously unselected package tipa.\n",
            "Preparing to unpack .../45-tipa_2%3a1.3-20_all.deb ...\n",
            "Unpacking tipa (2:1.3-20) ...\n",
            "Selecting previously unselected package texlive-xetex.\n",
            "Preparing to unpack .../46-texlive-xetex_2017.20180305-1_all.deb ...\n",
            "Unpacking texlive-xetex (2017.20180305-1) ...\n",
            "Setting up libgs9-common (9.26~dfsg+0-0ubuntu0.18.04.17) ...\n",
            "Setting up libkpathsea6:amd64 (2017.20170613.44572-8ubuntu0.1) ...\n",
            "Setting up libjs-jquery (3.2.1-1) ...\n",
            "Setting up libtexlua52:amd64 (2017.20170613.44572-8ubuntu0.1) ...\n",
            "Setting up fonts-droid-fallback (1:6.0.1r16-1.1) ...\n",
            "Setting up libsynctex1:amd64 (2017.20170613.44572-8ubuntu0.1) ...\n",
            "Setting up libptexenc1:amd64 (2017.20170613.44572-8ubuntu0.1) ...\n",
            "Setting up tex-common (6.09) ...\n",
            "update-language: texlive-base not installed and configured, doing nothing!\n",
            "Setting up poppler-data (0.4.8-2) ...\n",
            "Setting up tex-gyre (20160520-1) ...\n",
            "Setting up preview-latex-style (11.91-1ubuntu1) ...\n",
            "Setting up fonts-texgyre (20160520-1) ...\n",
            "Setting up fonts-noto-mono (20171026-2) ...\n",
            "Setting up fonts-lato (2.0-2) ...\n",
            "Setting up libcupsfilters1:amd64 (1.20.2-0ubuntu3.1) ...\n",
            "Setting up libcupsimage2:amd64 (2.2.7-1ubuntu2.9) ...\n",
            "Setting up libjbig2dec0:amd64 (0.13-6) ...\n",
            "Setting up ruby-did-you-mean (1.2.0-2) ...\n",
            "Setting up t1utils (1.41-2) ...\n",
            "Setting up ruby-net-telnet (0.1.1-2) ...\n",
            "Setting up libijs-0.35:amd64 (0.35-13) ...\n",
            "Setting up rubygems-integration (1.11) ...\n",
            "Setting up libpotrace0 (1.14-2) ...\n",
            "Setting up javascript-common (11) ...\n",
            "Setting up ruby-minitest (5.10.3-1) ...\n",
            "Setting up libzzip-0-13:amd64 (0.13.62-3.1ubuntu0.18.04.1) ...\n",
            "Setting up libgs9:amd64 (9.26~dfsg+0-0ubuntu0.18.04.17) ...\n",
            "Setting up libtexluajit2:amd64 (2017.20170613.44572-8ubuntu0.1) ...\n",
            "Setting up fonts-lmodern (2.004.5-3) ...\n",
            "Setting up ruby-power-assert (0.3.0-1) ...\n",
            "Setting up texlive-binaries (2017.20170613.44572-8ubuntu0.1) ...\n",
            "update-alternatives: using /usr/bin/xdvi-xaw to provide /usr/bin/xdvi.bin (xdvi.bin) in auto mode\n",
            "update-alternatives: using /usr/bin/bibtex.original to provide /usr/bin/bibtex (bibtex) in auto mode\n",
            "Setting up texlive-base (2017.20180305-1) ...\n",
            "mktexlsr: Updating /var/lib/texmf/ls-R-TEXLIVEDIST... \n",
            "mktexlsr: Updating /var/lib/texmf/ls-R-TEXMFMAIN... \n",
            "mktexlsr: Updating /var/lib/texmf/ls-R... \n",
            "mktexlsr: Done.\n",
            "tl-paper: setting paper size for dvips to a4: /var/lib/texmf/dvips/config/config-paper.ps\n",
            "tl-paper: setting paper size for dvipdfmx to a4: /var/lib/texmf/dvipdfmx/dvipdfmx-paper.cfg\n",
            "tl-paper: setting paper size for xdvi to a4: /var/lib/texmf/xdvi/XDvi-paper\n",
            "tl-paper: setting paper size for pdftex to a4: /var/lib/texmf/tex/generic/config/pdftexconfig.tex\n",
            "Setting up texlive-fonts-recommended (2017.20180305-1) ...\n",
            "Setting up texlive-plain-generic (2017.20180305-2) ...\n",
            "Setting up texlive-latex-base (2017.20180305-1) ...\n",
            "Setting up lmodern (2.004.5-3) ...\n",
            "Setting up texlive-latex-recommended (2017.20180305-1) ...\n",
            "Setting up texlive-pictures (2017.20180305-1) ...\n",
            "Setting up tipa (2:1.3-20) ...\n",
            "Regenerating '/var/lib/texmf/fmtutil.cnf-DEBIAN'... done.\n",
            "Regenerating '/var/lib/texmf/fmtutil.cnf-TEXLIVEDIST'... done.\n",
            "update-fmtutil has updated the following file(s):\n",
            "\t/var/lib/texmf/fmtutil.cnf-DEBIAN\n",
            "\t/var/lib/texmf/fmtutil.cnf-TEXLIVEDIST\n",
            "If you want to activate the changes in the above file(s),\n",
            "you should run fmtutil-sys or fmtutil.\n",
            "Setting up texlive (2017.20180305-1) ...\n",
            "Setting up texlive-latex-extra (2017.20180305-2) ...\n",
            "Setting up texlive-xetex (2017.20180305-1) ...\n",
            "Setting up ruby2.5 (2.5.1-1ubuntu1.12) ...\n",
            "Setting up ruby (1:2.5.1) ...\n",
            "Setting up ruby-test-unit (3.2.5-1) ...\n",
            "Setting up rake (12.3.1-1ubuntu0.1) ...\n",
            "Setting up libruby2.5:amd64 (2.5.1-1ubuntu1.12) ...\n",
            "Processing triggers for mime-support (3.60ubuntu1) ...\n",
            "Processing triggers for libc-bin (2.27-3ubuntu1.6) ...\n",
            "Processing triggers for man-db (2.8.3-2ubuntu0.1) ...\n",
            "Processing triggers for fontconfig (2.12.6-0ubuntu2) ...\n",
            "Processing triggers for tex-common (6.09) ...\n",
            "Running updmap-sys. This may take some time... done.\n",
            "Running mktexlsr /var/lib/texmf ... done.\n",
            "Building format(s) --all.\n",
            "\tThis may take some time... done.\n",
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting pypandoc\n",
            "  Downloading pypandoc-1.10-py3-none-any.whl (20 kB)\n",
            "Installing collected packages: pypandoc\n",
            "Successfully installed pypandoc-1.10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!jupyter nbconvert --to PDF '/content/drive/MyDrive/Colab Notebooks/MachineLearning2022-2/MachineLearning2022-2/assignment_12.ipynb'"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Mn7E7PKPuuGM",
        "outputId": "91375151-52e0-477d-abd2-01e8ff22ff44"
      },
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[NbConvertApp] Converting notebook /content/drive/MyDrive/Colab Notebooks/MachineLearning2022-2/MachineLearning2022-2/assignment_12.ipynb to PDF\n",
            "[NbConvertApp] Support files will be in assignment_12_files/\n",
            "[NbConvertApp] Making directory ./assignment_12_files\n",
            "[NbConvertApp] Writing 50606 bytes to ./notebook.tex\n",
            "[NbConvertApp] Building PDF\n",
            "[NbConvertApp] Running xelatex 3 times: ['xelatex', './notebook.tex', '-quiet']\n",
            "[NbConvertApp] Running bibtex 1 time: ['bibtex', './notebook']\n",
            "[NbConvertApp] WARNING | bibtex had problems, most likely because there were no citations\n",
            "[NbConvertApp] PDF successfully created\n",
            "[NbConvertApp] Writing 59438 bytes to /content/drive/MyDrive/Colab Notebooks/MachineLearning2022-2/MachineLearning2022-2/assignment_12.pdf\n",
            "[NbConvertApp] Converting notebook /content/drive/MyDrive/Colab Notebooks/MachineLearning2022-2/MachineLearning2022-2/assignment_12.ipynb.ipynb to PDF\n",
            "[NbConvertApp] Support files will be in assignment_12.ipynb_files/\n",
            "[NbConvertApp] Making directory ./assignment_12.ipynb_files\n",
            "[NbConvertApp] Making directory ./assignment_12.ipynb_files\n",
            "[NbConvertApp] Making directory ./assignment_12.ipynb_files\n",
            "[NbConvertApp] Making directory ./assignment_12.ipynb_files\n",
            "[NbConvertApp] Writing 92278 bytes to ./notebook.tex\n",
            "[NbConvertApp] Building PDF\n",
            "[NbConvertApp] Running xelatex 3 times: ['xelatex', './notebook.tex', '-quiet']\n",
            "[NbConvertApp] Running bibtex 1 time: ['bibtex', './notebook']\n",
            "[NbConvertApp] WARNING | bibtex had problems, most likely because there were no citations\n",
            "[NbConvertApp] PDF successfully created\n",
            "[NbConvertApp] Writing 132527 bytes to /content/drive/MyDrive/Colab Notebooks/MachineLearning2022-2/MachineLearning2022-2/assignment_12.ipynb.pdf\n"
          ]
        }
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "machine_shape": "hm"
    },
    "kernelspec": {
      "display_name": "Python 3.9.6 64-bit",
      "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.8.10"
    },
    "vscode": {
      "interpreter": {
        "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
      }
    },
    "accelerator": "GPU",
    "gpuClass": "premium"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}