main_oversampling.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "c:\\Users\\cseak\\anaconda3\\lib\\site-packages\\torchvision\\io\\image.py:11: UserWarning: Failed to load image Python extension: Could not find module 'C:\\Users\\cseak\\anaconda3\\Lib\\site-packages\\torchvision\\image.pyd' (or one of its dependencies). Try using the full path with constructor syntax.\n",
            "  warn(f\"Failed to load image Python extension: {e}\")\n"
          ]
        }
      ],
      "source": [
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "from sklearn.model_selection import train_test_split\n",
        "from collections import Counter\n",
        "import time\n",
        "import torch\n",
        "import os\n",
        "from PIL import Image\n",
        "\n",
        "import os\n",
        "import time\n",
        "import torchvision\n",
        "from torch import nn\n",
        "from torchsummary import summary\n",
        "from torch.utils.data import Subset, WeightedRandomSampler, Dataset, DataLoader\n",
        "import pandas as pd\n",
        "from torchvision import transforms\n",
        "\n",
        "from os.path import exists"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### Preprocessing"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "kLo5LnLudB6L"
      },
      "outputs": [],
      "source": [
        "## transform original label to csv format\n",
        "\n",
        "# trains = []\n",
        "# tests = []\n",
        "# with open('dataset/label.txt', 'r') as label_f:\n",
        "#   line = label_f.readline()\n",
        "#   while line:\n",
        "#     splitted = line.split(' ')\n",
        "#     names = splitted[0].split('.')\n",
        "#     if line.startswith('train_'):\n",
        "#       trains.append([str(names[0] + '_aligned.' + names[1]), int(splitted[1][0]) - 1])\n",
        "#     else:\n",
        "#       tests.append([str(names[0] + '_aligned.' + names[1]), int(splitted[1][0]) - 1])\n",
        "\n",
        "#     line = label_f.readline()\n",
        "\n",
        "# pd.DataFrame(data=trains, columns=['path', 'label']).to_csv('dataset/train.csv', index=False)\n",
        "# pd.DataFrame(data=tests, columns=['path', 'label']).to_csv('dataset/test.csv', index=False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(3    4772\n",
              " 6    2524\n",
              " 4    1982\n",
              " 0    1290\n",
              " 2     717\n",
              " 5     705\n",
              " 1     281\n",
              " Name: label, dtype: int64,\n",
              " 3    1185\n",
              " 6     680\n",
              " 4     478\n",
              " 0     329\n",
              " 5     162\n",
              " 2     160\n",
              " 1      74\n",
              " Name: label, dtype: int64)"
            ]
          },
          "execution_count": 3,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "CLASS_LABELS = {\n",
        "    '0': 'Surprise',\n",
        "    '1': 'Fear',\n",
        "    '2': 'Disgust',\n",
        "    '3': 'Happiness',\n",
        "    '4': 'Sadness',\n",
        "    '5': 'Anger',\n",
        "    '6': 'Neutral',\n",
        "}\n",
        "\n",
        "#Check dataset distribution\n",
        "pd.read_csv('dataset/train.csv')['label'].value_counts(), pd.read_csv('dataset/test.csv')['label'].value_counts()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "8RCAlKPwEeZz"
      },
      "outputs": [],
      "source": [
        "def imshow(inp, title=None):\n",
        "    \"\"\"Imshow for Tensor.\"\"\"\n",
        "    inp = inp.numpy().transpose((1, 2, 0))\n",
        "    inp = np.clip(inp, 0, 1)\n",
        "    plt.imshow(inp)\n",
        "    if title is not None:\n",
        "        plt.title(title)\n",
        "        \n",
        "    plt.pause(0.001)  # pause a bit so that plots are updated\n",
        "    \n",
        "    \n",
        "def load_image(path):\n",
        "    img = Image.open(path)\n",
        "    # img = Image.open(path)\n",
        "    img.load()\n",
        "    \n",
        "    return transforms.ToTensor()(img)\n",
        "\n",
        "# https://pytorch.org/tutorials/beginner/transfer_learning_tutorial.html"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### Dataset and Dataloader"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "IQcSupl5bp3r"
      },
      "outputs": [],
      "source": [
        "IMG_PATH = 'dataset/img/'\n",
        "# IMG_PATH = 'dataset/test/'\n",
        "INPUT_SIZE=100*100\n",
        "\n",
        "class CustomImageNetDataset(Dataset):\n",
        "    def __init__(self, transform=None, train=True):\n",
        "        self.img_path = IMG_PATH\n",
        "        self.df = pd.read_csv('dataset/train.csv' if train else 'dataset/test.csv')\n",
        "        # self.df = pd.read_csv('dataset/train.csv' if train else 'dataset/test.csv').sample(n=1000)\n",
        "\n",
        "        self.transform = transform\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.df.index)\n",
        "\n",
        "    def get_targets(self):\n",
        "        return self.df['label']\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        obj = self.df.iloc[idx]\n",
        "        image = load_image(self.img_path + obj['path'])\n",
        "        label = obj['label']\n",
        "\n",
        "        # if image.shape[0] == 1:\n",
        "        #   image = read_image(self.img_path + obj['name'], ImageReadMode.GRAY)\n",
        "\n",
        "        if self.transform:\n",
        "          image = self.transform(image.type(torch.FloatTensor))\n",
        "\n",
        "        return image, label\n",
        "\n",
        "class CustomDataModule:\n",
        "    def __init__(self, train_transforms = None, test_transforms = None, bs=32):\n",
        "        super().__init__()\n",
        "        self.bs = bs\n",
        "        \n",
        "        self.transform = train_transforms\n",
        "        \n",
        "        self.test_transform = test_transforms\n",
        "\n",
        "    def prepare_data(self):\n",
        "        pass\n",
        "\n",
        "    def __balance_val_split(self, dataset, val_split=0.):\n",
        "        targets = np.array(dataset.get_targets())\n",
        "        train_indices, val_indices = train_test_split(\n",
        "            np.arange(targets.shape[0]),\n",
        "            test_size=val_split,\n",
        "            stratify=targets\n",
        "        )\n",
        "        \n",
        "        train_dataset = Subset(dataset, indices=train_indices)\n",
        "        val_dataset = Subset(dataset, indices=val_indices)\n",
        "\n",
        "        return train_dataset, val_dataset\n",
        "    \n",
        "    def __oversampling(self, dataset):\n",
        "        targets = [label for img, label in iter(dataset)]\n",
        "            \n",
        "        max_cnt_in_dataset = 0\n",
        "        class_weights = []\n",
        "        for i in range(len(CLASS_LABELS)):\n",
        "            cnt_in_dataset = (np.array(targets) == i).sum()\n",
        "            class_weights.append(1 / cnt_in_dataset * 1000)\n",
        "            \n",
        "            if max_cnt_in_dataset < cnt_in_dataset:\n",
        "                max_cnt_in_dataset = cnt_in_dataset\n",
        "        \n",
        "        sample_weights = [0] * len(dataset)\n",
        "        for ind, (data, label) in enumerate(dataset):\n",
        "            sample_weights[ind] = class_weights[label]\n",
        "        \n",
        "        sampler = WeightedRandomSampler(sample_weights, num_samples=30000, replacement=True)\n",
        "        \n",
        "        return sampler\n",
        "        \n",
        "    def setup(self, stage=None):\n",
        "        if stage == \"fit\" or stage is None:\n",
        "            train_ds_all = CustomImageNetDataset(transform=self.transform, train=True)\n",
        "            self.train_ds, self.val_ds = self.__balance_val_split(train_ds_all, val_split=0.05)\n",
        "\n",
        "        if stage == \"test\" or stage == \"predict\" or stage is None:\n",
        "            self.test_ds = CustomImageNetDataset(transform=self.test_transform, train=False)\n",
        "\n",
        "        return self\n",
        "\n",
        "    def train_dataloader(self):\n",
        "        sampler = self.__oversampling(self.train_ds)\n",
        "        \n",
        "        # return DataLoader(self.train_ds, batch_size=self.bs)\n",
        "        return DataLoader(self.train_ds, batch_size=self.bs, sampler=sampler)\n",
        "\n",
        "    def val_dataloader(self):\n",
        "        # sampler = self.__oversampling(self.val_ds)\n",
        "        \n",
        "        return DataLoader(self.val_ds, batch_size=self.bs)\n",
        "\n",
        "    def test_dataloader(self):\n",
        "        return DataLoader(self.test_ds, batch_size=self.bs)\n",
        "\n",
        "    def predict_dataloader(self):\n",
        "        return DataLoader(self.test_ds, batch_size=self.bs)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Dataset count: 30000\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "Counter({2: 4332, 0: 4195, 5: 4310, 6: 4276, 1: 4178, 3: 4375, 4: 4334})"
            ]
          },
          "execution_count": 22,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "from collections import Counter\n",
        "\n",
        "dl = CustomDataModule().setup(\"fit\").train_dataloader()\n",
        "all_labels = []\n",
        "for imgs, labels in dl:\n",
        "    all_labels.extend(labels.detach_().cpu().tolist())\n",
        "\n",
        "\n",
        "# Check data distribution after applied oversampling based on weight\n",
        "print(\"Dataset count:\", len(all_labels))\n",
        "Counter(all_labels)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### CNN Model Initialization"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ngl3CuCw62kP",
        "outputId": "b31f45e0-e00a-4721-8771-a83340e54191"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "----------------------------------------------------------------\n",
            "        Layer (type)               Output Shape         Param #\n",
            "================================================================\n",
            "            Conv2d-1           [-1, 32, 94, 94]           4,736\n",
            "              ReLU-2           [-1, 32, 94, 94]               0\n",
            "            Conv2d-3           [-1, 64, 90, 90]          51,264\n",
            "              ReLU-4           [-1, 64, 90, 90]               0\n",
            "         MaxPool2d-5           [-1, 64, 30, 30]               0\n",
            "            Conv2d-6          [-1, 128, 26, 26]         204,928\n",
            "              ReLU-7          [-1, 128, 26, 26]               0\n",
            "         AvgPool2d-8            [-1, 128, 8, 8]               0\n",
            "            Conv2d-9            [-1, 128, 6, 6]         147,584\n",
            "             ReLU-10            [-1, 128, 6, 6]               0\n",
            "        AvgPool2d-11            [-1, 128, 2, 2]               0\n",
            "          Flatten-12                  [-1, 512]               0\n",
            "           Linear-13                  [-1, 128]          65,664\n",
            "             ReLU-14                  [-1, 128]               0\n",
            "          Dropout-15                  [-1, 128]               0\n",
            "           Linear-16                    [-1, 7]             903\n",
            "================================================================\n",
            "Total params: 475,079\n",
            "Trainable params: 475,079\n",
            "Non-trainable params: 0\n",
            "----------------------------------------------------------------\n",
            "Input size (MB): 0.11\n",
            "Forward/backward pass size (MB): 14.13\n",
            "Params size (MB): 1.81\n",
            "Estimated Total Size (MB): 16.05\n",
            "----------------------------------------------------------------\n"
          ]
        }
      ],
      "source": [
        "class FacialClassification(nn.Module):\n",
        "    def __init__(self, in_channels=3):\n",
        "        super().__init__()\n",
        "\n",
        "        self.conv_layer = nn.Sequential(\n",
        "            nn.Conv2d(in_channels=in_channels, out_channels=32, kernel_size=7),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.Conv2d(in_channels=32, out_channels=64, kernel_size=5),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.MaxPool2d(kernel_size=3),\n",
        "            \n",
        "            nn.Conv2d(in_channels=64, out_channels=128, kernel_size=5),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.AvgPool2d(kernel_size=3),\n",
        "            \n",
        "            nn.Conv2d(in_channels=128, out_channels=128, kernel_size=3),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.AvgPool2d(kernel_size=3),\n",
        "        )\n",
        "\n",
        "        # self.avgpool = nn.AdaptiveAvgPool2d((1, 1))\n",
        "\n",
        "        self.fc = nn.Sequential(\n",
        "            nn.Flatten(),\n",
        "            nn.Linear(in_features=512, out_features=128),\n",
        "            nn.ReLU(),\n",
        "            nn.Dropout(p=0.1),\n",
        "            nn.Linear(in_features=128, out_features=len(CLASS_LABELS))\n",
        "        )\n",
        "    \n",
        "    def forward(self, x):\n",
        "        # print(x.shape)\n",
        "        x = self.conv_layer(x)\n",
        "\n",
        "        x = self.fc(x)\n",
        "\n",
        "        return x\n",
        "\n",
        "summary(FacialClassification(3).to(\"cuda\"), (3, 100, 100))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "id": "2PHvUN0Dbb39"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "----------------------------------------------------------------\n",
            "        Layer (type)               Output Shape         Param #\n",
            "================================================================\n",
            "            Conv2d-1           [-1, 64, 50, 50]           9,408\n",
            "       BatchNorm2d-2           [-1, 64, 50, 50]             128\n",
            "              ReLU-3           [-1, 64, 50, 50]               0\n",
            "         MaxPool2d-4           [-1, 64, 25, 25]               0\n",
            "            Conv2d-5           [-1, 64, 25, 25]          36,864\n",
            "       BatchNorm2d-6           [-1, 64, 25, 25]             128\n",
            "              ReLU-7           [-1, 64, 25, 25]               0\n",
            "            Conv2d-8           [-1, 64, 25, 25]          36,864\n",
            "       BatchNorm2d-9           [-1, 64, 25, 25]             128\n",
            "             ReLU-10           [-1, 64, 25, 25]               0\n",
            "       BasicBlock-11           [-1, 64, 25, 25]               0\n",
            "           Conv2d-12           [-1, 64, 25, 25]          36,864\n",
            "      BatchNorm2d-13           [-1, 64, 25, 25]             128\n",
            "             ReLU-14           [-1, 64, 25, 25]               0\n",
            "           Conv2d-15           [-1, 64, 25, 25]          36,864\n",
            "      BatchNorm2d-16           [-1, 64, 25, 25]             128\n",
            "             ReLU-17           [-1, 64, 25, 25]               0\n",
            "       BasicBlock-18           [-1, 64, 25, 25]               0\n",
            "           Conv2d-19          [-1, 128, 13, 13]          73,728\n",
            "      BatchNorm2d-20          [-1, 128, 13, 13]             256\n",
            "             ReLU-21          [-1, 128, 13, 13]               0\n",
            "           Conv2d-22          [-1, 128, 13, 13]         147,456\n",
            "      BatchNorm2d-23          [-1, 128, 13, 13]             256\n",
            "           Conv2d-24          [-1, 128, 13, 13]           8,192\n",
            "      BatchNorm2d-25          [-1, 128, 13, 13]             256\n",
            "             ReLU-26          [-1, 128, 13, 13]               0\n",
            "       BasicBlock-27          [-1, 128, 13, 13]               0\n",
            "           Conv2d-28          [-1, 128, 13, 13]         147,456\n",
            "      BatchNorm2d-29          [-1, 128, 13, 13]             256\n",
            "             ReLU-30          [-1, 128, 13, 13]               0\n",
            "           Conv2d-31          [-1, 128, 13, 13]         147,456\n",
            "      BatchNorm2d-32          [-1, 128, 13, 13]             256\n",
            "             ReLU-33          [-1, 128, 13, 13]               0\n",
            "       BasicBlock-34          [-1, 128, 13, 13]               0\n",
            "           Conv2d-35            [-1, 256, 7, 7]         294,912\n",
            "      BatchNorm2d-36            [-1, 256, 7, 7]             512\n",
            "             ReLU-37            [-1, 256, 7, 7]               0\n",
            "           Conv2d-38            [-1, 256, 7, 7]         589,824\n",
            "      BatchNorm2d-39            [-1, 256, 7, 7]             512\n",
            "           Conv2d-40            [-1, 256, 7, 7]          32,768\n",
            "      BatchNorm2d-41            [-1, 256, 7, 7]             512\n",
            "             ReLU-42            [-1, 256, 7, 7]               0\n",
            "       BasicBlock-43            [-1, 256, 7, 7]               0\n",
            "           Conv2d-44            [-1, 256, 7, 7]         589,824\n",
            "      BatchNorm2d-45            [-1, 256, 7, 7]             512\n",
            "             ReLU-46            [-1, 256, 7, 7]               0\n",
            "           Conv2d-47            [-1, 256, 7, 7]         589,824\n",
            "      BatchNorm2d-48            [-1, 256, 7, 7]             512\n",
            "             ReLU-49            [-1, 256, 7, 7]               0\n",
            "       BasicBlock-50            [-1, 256, 7, 7]               0\n",
            "           Conv2d-51            [-1, 512, 4, 4]       1,179,648\n",
            "      BatchNorm2d-52            [-1, 512, 4, 4]           1,024\n",
            "             ReLU-53            [-1, 512, 4, 4]               0\n",
            "           Conv2d-54            [-1, 512, 4, 4]       2,359,296\n",
            "      BatchNorm2d-55            [-1, 512, 4, 4]           1,024\n",
            "           Conv2d-56            [-1, 512, 4, 4]         131,072\n",
            "      BatchNorm2d-57            [-1, 512, 4, 4]           1,024\n",
            "             ReLU-58            [-1, 512, 4, 4]               0\n",
            "       BasicBlock-59            [-1, 512, 4, 4]               0\n",
            "           Conv2d-60            [-1, 512, 4, 4]       2,359,296\n",
            "      BatchNorm2d-61            [-1, 512, 4, 4]           1,024\n",
            "             ReLU-62            [-1, 512, 4, 4]               0\n",
            "           Conv2d-63            [-1, 512, 4, 4]       2,359,296\n",
            "      BatchNorm2d-64            [-1, 512, 4, 4]           1,024\n",
            "             ReLU-65            [-1, 512, 4, 4]               0\n",
            "       BasicBlock-66            [-1, 512, 4, 4]               0\n",
            "AdaptiveAvgPool2d-67            [-1, 512, 1, 1]               0\n",
            "           Linear-68                    [-1, 7]           3,591\n",
            "           ResNet-69                    [-1, 7]               0\n",
            "================================================================\n",
            "Total params: 11,180,103\n",
            "Trainable params: 3,591\n",
            "Non-trainable params: 11,176,512\n",
            "----------------------------------------------------------------\n",
            "Input size (MB): 0.11\n",
            "Forward/backward pass size (MB): 13.42\n",
            "Params size (MB): 42.65\n",
            "Estimated Total Size (MB): 56.18\n",
            "----------------------------------------------------------------\n"
          ]
        }
      ],
      "source": [
        "class FacialClassificationTL(nn.Module):\n",
        "    def __init__(self, in_channels=3, requires_grad=False, pretrained=True):\n",
        "        super().__init__()\n",
        "\n",
        "        self.model_ft = torchvision.models.resnet18(pretrained=pretrained)\n",
        "\n",
        "        for param in self.model_ft.parameters():\n",
        "            param.requires_grad_(requires_grad)\n",
        "        \n",
        "        self.model_ft.conv1.in_channels = in_channels\n",
        "        num_ftrs = self.model_ft.fc.in_features\n",
        "        \n",
        "        self.model_ft.fc = nn.Linear(num_ftrs, len(CLASS_LABELS))\n",
        "\n",
        "    def forward(self, x):\n",
        "      out = self.model_ft(x)\n",
        "\n",
        "      return out\n",
        "  \n",
        "# FacialClassificationTL()\n",
        "summary(FacialClassificationTL(3).to(\"cuda\"), (3, 100, 100))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Display sample image"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 298
        },
        "id": "rd_2XV5M_QNA",
        "outputId": "9affa24f-bce6-46ec-c8b8-c026138028d1"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x252e5849970>"
            ]
          },
          "execution_count": 9,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "image/svg+xml": "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>\r\n<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\r\n  \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\r\n<svg height=\"263.63625pt\" version=\"1.1\" viewBox=\"0 0 251.565 263.63625\" width=\"251.565pt\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\r\n <metadata>\r\n  <rdf:RDF xmlns:cc=\"http://creativecommons.org/ns#\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">\r\n   <cc:Work>\r\n    <dc:type rdf:resource=\"http://purl.org/dc/dcmitype/StillImage\"/>\r\n    <dc:date>2022-07-07T00:20:26.865715</dc:date>\r\n    <dc:format>image/svg+xml</dc:format>\r\n    <dc:creator>\r\n     <cc:Agent>\r\n      <dc:title>Matplotlib v3.4.3, https://matplotlib.org/</dc:title>\r\n     </cc:Agent>\r\n    </dc:creator>\r\n   </cc:Work>\r\n  </rdf:RDF>\r\n </metadata>\r\n <defs>\r\n  <style type=\"text/css\">*{stroke-linecap:butt;stroke-linejoin:round;}</style>\r\n </defs>\r\n <g id=\"figure_1\">\r\n  <g id=\"patch_1\">\r\n   <path d=\"M 0 263.63625 \r\nL 251.565 263.63625 \r\nL 251.565 0 \r\nL 0 0 \r\nz\r\n\"/>\r\n  </g>\r\n  <g id=\"axes_1\">\r\n   <g id=\"patch_2\">\r\n    <path d=\"M 26.925 239.758125 \r\nL 244.365 239.758125 \r\nL 244.365 22.318125 \r\nL 26.925 22.318125 \r\nz\r\n\"/>\r\n   </g>\r\n   <g clip-path=\"url(#p2b11b4a096)\">\r\n    <image height=\"218\" id=\"image139891d0c9\" transform=\"scale(1 -1)translate(0 -218)\" width=\"218\" x=\"26.925\" xlink:href=\"data:image/png;base64,\r\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\" y=\"-21.758125\"/>\r\n   </g>\r\n   <g id=\"matplotlib.axis_1\">\r\n    <g id=\"xtick_1\">\r\n     <g id=\"line2d_1\">\r\n      <defs>\r\n       <path d=\"M 0 0 \r\nL 0 3.5 \r\n\" id=\"m0766cb364b\" style=\"stroke:#ffffff;stroke-width:0.8;\"/>\r\n      </defs>\r\n      <g>\r\n       <use style=\"fill:#ffffff;stroke:#ffffff;stroke-width:0.8;\" x=\"28.0122\" xlink:href=\"#m0766cb364b\" y=\"239.758125\"/>\r\n      </g>\r\n     </g>\r\n     <g id=\"text_1\">\r\n      <!-- 0 -->\r\n      <g style=\"fill:#ffffff;\" transform=\"translate(24.83095 254.356563)scale(0.1 -0.1)\">\r\n       <defs>\r\n        <path d=\"M 2034 4250 \r\nQ 1547 4250 1301 3770 \r\nQ 1056 3291 1056 2328 \r\nQ 1056 1369 1301 889 \r\nQ 1547 409 2034 409 \r\nQ 2525 409 2770 889 \r\nQ 3016 1369 3016 2328 \r\nQ 3016 3291 2770 3770 \r\nQ 2525 4250 2034 4250 \r\nz\r\nM 2034 4750 \r\nQ 2819 4750 3233 4129 \r\nQ 3647 3509 3647 2328 \r\nQ 3647 1150 3233 529 \r\nQ 2819 -91 2034 -91 \r\nQ 1250 -91 836 529 \r\nQ 422 1150 422 2328 \r\nQ 422 3509 836 4129 \r\nQ 1250 4750 2034 4750 \r\nz\r\n\" id=\"DejaVuSans-30\" transform=\"scale(0.015625)\"/>\r\n       </defs>\r\n       <use xlink:href=\"#DejaVuSans-30\"/>\r\n      </g>\r\n     </g>\r\n    </g>\r\n    <g id=\"xtick_2\">\r\n     <g id=\"line2d_2\">\r\n      <g>\r\n       <use style=\"fill:#ffffff;stroke:#ffffff;stroke-width:0.8;\" x=\"71.5002\" xlink:href=\"#m0766cb364b\" y=\"239.758125\"/>\r\n      </g>\r\n     </g>\r\n     <g id=\"text_2\">\r\n      <!-- 20 -->\r\n      <g style=\"fill:#ffffff;\" transform=\"translate(65.1377 254.356563)scale(0.1 -0.1)\">\r\n       <defs>\r\n        <path d=\"M 1228 531 \r\nL 3431 531 \r\nL 3431 0 \r\nL 469 0 \r\nL 469 531 \r\nQ 828 903 1448 1529 \r\nQ 2069 2156 2228 2338 \r\nQ 2531 2678 2651 2914 \r\nQ 2772 3150 2772 3378 \r\nQ 2772 3750 2511 3984 \r\nQ 2250 4219 1831 4219 \r\nQ 1534 4219 1204 4116 \r\nQ 875 4013 500 3803 \r\nL 500 4441 \r\nQ 881 4594 1212 4672 \r\nQ 1544 4750 1819 4750 \r\nQ 2544 4750 2975 4387 \r\nQ 3406 4025 3406 3419 \r\nQ 3406 3131 3298 2873 \r\nQ 3191 2616 2906 2266 \r\nQ 2828 2175 2409 1742 \r\nQ 1991 1309 1228 531 \r\nz\r\n\" id=\"DejaVuSans-32\" transform=\"scale(0.015625)\"/>\r\n       </defs>\r\n       <use xlink:href=\"#DejaVuSans-32\"/>\r\n       <use x=\"63.623047\" xlink:href=\"#DejaVuSans-30\"/>\r\n      </g>\r\n     </g>\r\n    </g>\r\n    <g id=\"xtick_3\">\r\n     <g id=\"line2d_3\">\r\n      <g>\r\n       <use style=\"fill:#ffffff;stroke:#ffffff;stroke-width:0.8;\" x=\"114.9882\" xlink:href=\"#m0766cb364b\" y=\"239.758125\"/>\r\n      </g>\r\n     </g>\r\n     <g id=\"text_3\">\r\n      <!-- 40 -->\r\n      <g style=\"fill:#ffffff;\" transform=\"translate(108.6257 254.356563)scale(0.1 -0.1)\">\r\n       <defs>\r\n        <path d=\"M 2419 4116 \r\nL 825 1625 \r\nL 2419 1625 \r\nL 2419 4116 \r\nz\r\nM 2253 4666 \r\nL 3047 4666 \r\nL 3047 1625 \r\nL 3713 1625 \r\nL 3713 1100 \r\nL 3047 1100 \r\nL 3047 0 \r\nL 2419 0 \r\nL 2419 1100 \r\nL 313 1100 \r\nL 313 1709 \r\nL 2253 4666 \r\nz\r\n\" id=\"DejaVuSans-34\" transform=\"scale(0.015625)\"/>\r\n       </defs>\r\n       <use xlink:href=\"#DejaVuSans-34\"/>\r\n       <use x=\"63.623047\" xlink:href=\"#DejaVuSans-30\"/>\r\n      </g>\r\n     </g>\r\n    </g>\r\n    <g id=\"xtick_4\">\r\n     <g id=\"line2d_4\">\r\n      <g>\r\n       <use style=\"fill:#ffffff;stroke:#ffffff;stroke-width:0.8;\" x=\"158.4762\" xlink:href=\"#m0766cb364b\" y=\"239.758125\"/>\r\n      </g>\r\n     </g>\r\n     <g id=\"text_4\">\r\n      <!-- 60 -->\r\n      <g style=\"fill:#ffffff;\" transform=\"translate(152.1137 254.356563)scale(0.1 -0.1)\">\r\n       <defs>\r\n        <path d=\"M 2113 2584 \r\nQ 1688 2584 1439 2293 \r\nQ 1191 2003 1191 1497 \r\nQ 1191 994 1439 701 \r\nQ 1688 409 2113 409 \r\nQ 2538 409 2786 701 \r\nQ 3034 994 3034 1497 \r\nQ 3034 2003 2786 2293 \r\nQ 2538 2584 2113 2584 \r\nz\r\nM 3366 4563 \r\nL 3366 3988 \r\nQ 3128 4100 2886 4159 \r\nQ 2644 4219 2406 4219 \r\nQ 1781 4219 1451 3797 \r\nQ 1122 3375 1075 2522 \r\nQ 1259 2794 1537 2939 \r\nQ 1816 3084 2150 3084 \r\nQ 2853 3084 3261 2657 \r\nQ 3669 2231 3669 1497 \r\nQ 3669 778 3244 343 \r\nQ 2819 -91 2113 -91 \r\nQ 1303 -91 875 529 \r\nQ 447 1150 447 2328 \r\nQ 447 3434 972 4092 \r\nQ 1497 4750 2381 4750 \r\nQ 2619 4750 2861 4703 \r\nQ 3103 4656 3366 4563 \r\nz\r\n\" id=\"DejaVuSans-36\" transform=\"scale(0.015625)\"/>\r\n       </defs>\r\n       <use xlink:href=\"#DejaVuSans-36\"/>\r\n       <use x=\"63.623047\" xlink:href=\"#DejaVuSans-30\"/>\r\n      </g>\r\n     </g>\r\n    </g>\r\n    <g id=\"xtick_5\">\r\n     <g id=\"line2d_5\">\r\n      <g>\r\n       <use style=\"fill:#ffffff;stroke:#ffffff;stroke-width:0.8;\" x=\"201.9642\" xlink:href=\"#m0766cb364b\" y=\"239.758125\"/>\r\n      </g>\r\n     </g>\r\n     <g id=\"text_5\">\r\n      <!-- 80 -->\r\n      <g style=\"fill:#ffffff;\" transform=\"translate(195.6017 254.356563)scale(0.1 -0.1)\">\r\n       <defs>\r\n        <path d=\"M 2034 2216 \r\nQ 1584 2216 1326 1975 \r\nQ 1069 1734 1069 1313 \r\nQ 1069 891 1326 650 \r\nQ 1584 409 2034 409 \r\nQ 2484 409 2743 651 \r\nQ 3003 894 3003 1313 \r\nQ 3003 1734 2745 1975 \r\nQ 2488 2216 2034 2216 \r\nz\r\nM 1403 2484 \r\nQ 997 2584 770 2862 \r\nQ 544 3141 544 3541 \r\nQ 544 4100 942 4425 \r\nQ 1341 4750 2034 4750 \r\nQ 2731 4750 3128 4425 \r\nQ 3525 4100 3525 3541 \r\nQ 3525 3141 3298 2862 \r\nQ 3072 2584 2669 2484 \r\nQ 3125 2378 3379 2068 \r\nQ 3634 1759 3634 1313 \r\nQ 3634 634 3220 271 \r\nQ 2806 -91 2034 -91 \r\nQ 1263 -91 848 271 \r\nQ 434 634 434 1313 \r\nQ 434 1759 690 2068 \r\nQ 947 2378 1403 2484 \r\nz\r\nM 1172 3481 \r\nQ 1172 3119 1398 2916 \r\nQ 1625 2713 2034 2713 \r\nQ 2441 2713 2670 2916 \r\nQ 2900 3119 2900 3481 \r\nQ 2900 3844 2670 4047 \r\nQ 2441 4250 2034 4250 \r\nQ 1625 4250 1398 4047 \r\nQ 1172 3844 1172 3481 \r\nz\r\n\" id=\"DejaVuSans-38\" transform=\"scale(0.015625)\"/>\r\n       </defs>\r\n       <use xlink:href=\"#DejaVuSans-38\"/>\r\n       <use x=\"63.623047\" xlink:href=\"#DejaVuSans-30\"/>\r\n      </g>\r\n     </g>\r\n    </g>\r\n   </g>\r\n   <g id=\"matplotlib.axis_2\">\r\n    <g id=\"ytick_1\">\r\n     <g id=\"line2d_6\">\r\n      <defs>\r\n       <path d=\"M 0 0 \r\nL -3.5 0 \r\n\" id=\"m3188cb2979\" style=\"stroke:#ffffff;stroke-width:0.8;\"/>\r\n      </defs>\r\n      <g>\r\n       <use style=\"fill:#ffffff;stroke:#ffffff;stroke-width:0.8;\" x=\"26.925\" xlink:href=\"#m3188cb2979\" y=\"23.405325\"/>\r\n      </g>\r\n     </g>\r\n     <g id=\"text_6\">\r\n      <!-- 0 -->\r\n      <g style=\"fill:#ffffff;\" transform=\"translate(13.5625 27.204544)scale(0.1 -0.1)\">\r\n       <use xlink:href=\"#DejaVuSans-30\"/>\r\n      </g>\r\n     </g>\r\n    </g>\r\n    <g id=\"ytick_2\">\r\n     <g id=\"line2d_7\">\r\n      <g>\r\n       <use style=\"fill:#ffffff;stroke:#ffffff;stroke-width:0.8;\" x=\"26.925\" xlink:href=\"#m3188cb2979\" y=\"66.893325\"/>\r\n      </g>\r\n     </g>\r\n     <g id=\"text_7\">\r\n      <!-- 20 -->\r\n      <g style=\"fill:#ffffff;\" transform=\"translate(7.2 70.692544)scale(0.1 -0.1)\">\r\n       <use xlink:href=\"#DejaVuSans-32\"/>\r\n       <use x=\"63.623047\" xlink:href=\"#DejaVuSans-30\"/>\r\n      </g>\r\n     </g>\r\n    </g>\r\n    <g id=\"ytick_3\">\r\n     <g id=\"line2d_8\">\r\n      <g>\r\n       <use style=\"fill:#ffffff;stroke:#ffffff;stroke-width:0.8;\" x=\"26.925\" xlink:href=\"#m3188cb2979\" y=\"110.381325\"/>\r\n      </g>\r\n     </g>\r\n     <g id=\"text_8\">\r\n      <!-- 40 -->\r\n      <g style=\"fill:#ffffff;\" transform=\"translate(7.2 114.180544)scale(0.1 -0.1)\">\r\n       <use xlink:href=\"#DejaVuSans-34\"/>\r\n       <use x=\"63.623047\" xlink:href=\"#DejaVuSans-30\"/>\r\n      </g>\r\n     </g>\r\n    </g>\r\n    <g id=\"ytick_4\">\r\n     <g id=\"line2d_9\">\r\n      <g>\r\n       <use style=\"fill:#ffffff;stroke:#ffffff;stroke-width:0.8;\" x=\"26.925\" xlink:href=\"#m3188cb2979\" y=\"153.869325\"/>\r\n      </g>\r\n     </g>\r\n     <g id=\"text_9\">\r\n      <!-- 60 -->\r\n      <g style=\"fill:#ffffff;\" transform=\"translate(7.2 157.668544)scale(0.1 -0.1)\">\r\n       <use xlink:href=\"#DejaVuSans-36\"/>\r\n       <use x=\"63.623047\" xlink:href=\"#DejaVuSans-30\"/>\r\n      </g>\r\n     </g>\r\n    </g>\r\n    <g id=\"ytick_5\">\r\n     <g id=\"line2d_10\">\r\n      <g>\r\n       <use style=\"fill:#ffffff;stroke:#ffffff;stroke-width:0.8;\" x=\"26.925\" xlink:href=\"#m3188cb2979\" y=\"197.357325\"/>\r\n      </g>\r\n     </g>\r\n     <g id=\"text_10\">\r\n      <!-- 80 -->\r\n      <g style=\"fill:#ffffff;\" transform=\"translate(7.2 201.156544)scale(0.1 -0.1)\">\r\n       <use xlink:href=\"#DejaVuSans-38\"/>\r\n       <use x=\"63.623047\" xlink:href=\"#DejaVuSans-30\"/>\r\n      </g>\r\n     </g>\r\n    </g>\r\n   </g>\r\n   <g id=\"patch_3\">\r\n    <path d=\"M 26.925 239.758125 \r\nL 26.925 22.318125 \r\n\" style=\"fill:none;stroke:#ffffff;stroke-linecap:square;stroke-linejoin:miter;stroke-width:0.8;\"/>\r\n   </g>\r\n   <g id=\"patch_4\">\r\n    <path d=\"M 244.365 239.758125 \r\nL 244.365 22.318125 \r\n\" style=\"fill:none;stroke:#ffffff;stroke-linecap:square;stroke-linejoin:miter;stroke-width:0.8;\"/>\r\n   </g>\r\n   <g id=\"patch_5\">\r\n    <path d=\"M 26.925 239.758125 \r\nL 244.365 239.758125 \r\n\" style=\"fill:none;stroke:#ffffff;stroke-linecap:square;stroke-linejoin:miter;stroke-width:0.8;\"/>\r\n   </g>\r\n   <g id=\"patch_6\">\r\n    <path d=\"M 26.925 22.318125 \r\nL 244.365 22.318125 \r\n\" style=\"fill:none;stroke:#ffffff;stroke-linecap:square;stroke-linejoin:miter;stroke-width:0.8;\"/>\r\n   </g>\r\n   <g id=\"text_11\">\r\n    <!-- Happiness -->\r\n    <g style=\"fill:#ffffff;\" transform=\"translate(104.425312 16.318125)scale(0.12 -0.12)\">\r\n     <defs>\r\n      <path d=\"M 628 4666 \r\nL 1259 4666 \r\nL 1259 2753 \r\nL 3553 2753 \r\nL 3553 4666 \r\nL 4184 4666 \r\nL 4184 0 \r\nL 3553 0 \r\nL 3553 2222 \r\nL 1259 2222 \r\nL 1259 0 \r\nL 628 0 \r\nL 628 4666 \r\nz\r\n\" id=\"DejaVuSans-48\" transform=\"scale(0.015625)\"/>\r\n      <path d=\"M 2194 1759 \r\nQ 1497 1759 1228 1600 \r\nQ 959 1441 959 1056 \r\nQ 959 750 1161 570 \r\nQ 1363 391 1709 391 \r\nQ 2188 391 2477 730 \r\nQ 2766 1069 2766 1631 \r\nL 2766 1759 \r\nL 2194 1759 \r\nz\r\nM 3341 1997 \r\nL 3341 0 \r\nL 2766 0 \r\nL 2766 531 \r\nQ 2569 213 2275 61 \r\nQ 1981 -91 1556 -91 \r\nQ 1019 -91 701 211 \r\nQ 384 513 384 1019 \r\nQ 384 1609 779 1909 \r\nQ 1175 2209 1959 2209 \r\nL 2766 2209 \r\nL 2766 2266 \r\nQ 2766 2663 2505 2880 \r\nQ 2244 3097 1772 3097 \r\nQ 1472 3097 1187 3025 \r\nQ 903 2953 641 2809 \r\nL 641 3341 \r\nQ 956 3463 1253 3523 \r\nQ 1550 3584 1831 3584 \r\nQ 2591 3584 2966 3190 \r\nQ 3341 2797 3341 1997 \r\nz\r\n\" id=\"DejaVuSans-61\" transform=\"scale(0.015625)\"/>\r\n      <path d=\"M 1159 525 \r\nL 1159 -1331 \r\nL 581 -1331 \r\nL 581 3500 \r\nL 1159 3500 \r\nL 1159 2969 \r\nQ 1341 3281 1617 3432 \r\nQ 1894 3584 2278 3584 \r\nQ 2916 3584 3314 3078 \r\nQ 3713 2572 3713 1747 \r\nQ 3713 922 3314 415 \r\nQ 2916 -91 2278 -91 \r\nQ 1894 -91 1617 61 \r\nQ 1341 213 1159 525 \r\nz\r\nM 3116 1747 \r\nQ 3116 2381 2855 2742 \r\nQ 2594 3103 2138 3103 \r\nQ 1681 3103 1420 2742 \r\nQ 1159 2381 1159 1747 \r\nQ 1159 1113 1420 752 \r\nQ 1681 391 2138 391 \r\nQ 2594 391 2855 752 \r\nQ 3116 1113 3116 1747 \r\nz\r\n\" id=\"DejaVuSans-70\" transform=\"scale(0.015625)\"/>\r\n      <path d=\"M 603 3500 \r\nL 1178 3500 \r\nL 1178 0 \r\nL 603 0 \r\nL 603 3500 \r\nz\r\nM 603 4863 \r\nL 1178 4863 \r\nL 1178 4134 \r\nL 603 4134 \r\nL 603 4863 \r\nz\r\n\" id=\"DejaVuSans-69\" transform=\"scale(0.015625)\"/>\r\n      <path d=\"M 3513 2113 \r\nL 3513 0 \r\nL 2938 0 \r\nL 2938 2094 \r\nQ 2938 2591 2744 2837 \r\nQ 2550 3084 2163 3084 \r\nQ 1697 3084 1428 2787 \r\nQ 1159 2491 1159 1978 \r\nL 1159 0 \r\nL 581 0 \r\nL 581 3500 \r\nL 1159 3500 \r\nL 1159 2956 \r\nQ 1366 3272 1645 3428 \r\nQ 1925 3584 2291 3584 \r\nQ 2894 3584 3203 3211 \r\nQ 3513 2838 3513 2113 \r\nz\r\n\" id=\"DejaVuSans-6e\" transform=\"scale(0.015625)\"/>\r\n      <path d=\"M 3597 1894 \r\nL 3597 1613 \r\nL 953 1613 \r\nQ 991 1019 1311 708 \r\nQ 1631 397 2203 397 \r\nQ 2534 397 2845 478 \r\nQ 3156 559 3463 722 \r\nL 3463 178 \r\nQ 3153 47 2828 -22 \r\nQ 2503 -91 2169 -91 \r\nQ 1331 -91 842 396 \r\nQ 353 884 353 1716 \r\nQ 353 2575 817 3079 \r\nQ 1281 3584 2069 3584 \r\nQ 2775 3584 3186 3129 \r\nQ 3597 2675 3597 1894 \r\nz\r\nM 3022 2063 \r\nQ 3016 2534 2758 2815 \r\nQ 2500 3097 2075 3097 \r\nQ 1594 3097 1305 2825 \r\nQ 1016 2553 972 2059 \r\nL 3022 2063 \r\nz\r\n\" id=\"DejaVuSans-65\" transform=\"scale(0.015625)\"/>\r\n      <path d=\"M 2834 3397 \r\nL 2834 2853 \r\nQ 2591 2978 2328 3040 \r\nQ 2066 3103 1784 3103 \r\nQ 1356 3103 1142 2972 \r\nQ 928 2841 928 2578 \r\nQ 928 2378 1081 2264 \r\nQ 1234 2150 1697 2047 \r\nL 1894 2003 \r\nQ 2506 1872 2764 1633 \r\nQ 3022 1394 3022 966 \r\nQ 3022 478 2636 193 \r\nQ 2250 -91 1575 -91 \r\nQ 1294 -91 989 -36 \r\nQ 684 19 347 128 \r\nL 347 722 \r\nQ 666 556 975 473 \r\nQ 1284 391 1588 391 \r\nQ 1994 391 2212 530 \r\nQ 2431 669 2431 922 \r\nQ 2431 1156 2273 1281 \r\nQ 2116 1406 1581 1522 \r\nL 1381 1569 \r\nQ 847 1681 609 1914 \r\nQ 372 2147 372 2553 \r\nQ 372 3047 722 3315 \r\nQ 1072 3584 1716 3584 \r\nQ 2034 3584 2315 3537 \r\nQ 2597 3491 2834 3397 \r\nz\r\n\" id=\"DejaVuSans-73\" transform=\"scale(0.015625)\"/>\r\n     </defs>\r\n     <use xlink:href=\"#DejaVuSans-48\"/>\r\n     <use x=\"75.195312\" xlink:href=\"#DejaVuSans-61\"/>\r\n     <use x=\"136.474609\" xlink:href=\"#DejaVuSans-70\"/>\r\n     <use x=\"199.951172\" xlink:href=\"#DejaVuSans-70\"/>\r\n     <use x=\"263.427734\" xlink:href=\"#DejaVuSans-69\"/>\r\n     <use x=\"291.210938\" xlink:href=\"#DejaVuSans-6e\"/>\r\n     <use x=\"354.589844\" xlink:href=\"#DejaVuSans-65\"/>\r\n     <use x=\"416.113281\" xlink:href=\"#DejaVuSans-73\"/>\r\n     <use x=\"468.212891\" xlink:href=\"#DejaVuSans-73\"/>\r\n    </g>\r\n   </g>\r\n  </g>\r\n </g>\r\n <defs>\r\n  <clipPath id=\"p2b11b4a096\">\r\n   <rect height=\"217.44\" width=\"217.44\" x=\"26.925\" y=\"22.318125\"/>\r\n  </clipPath>\r\n </defs>\r\n</svg>\r\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "img, label = next(iter(CustomDataModule().setup(\"fit\").train_dataloader().dataset))\n",
        "# one_img = btx[0][0]\n",
        "# one_label = btx[1][0]\n",
        "# one_img.shape\n",
        "# imshow(img)\n",
        "\n",
        "plt.title(CLASS_LABELS[str(label)])\n",
        "img =img.numpy()\n",
        "if img.shape[0] == 3:\n",
        "  img = img.transpose((1, 2, 0))\n",
        "plt.imshow(img.squeeze(), cmap='gray' if img.shape[0] == 1 else None)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### Train, Evaluate functions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {},
      "outputs": [],
      "source": [
        "DEVICE = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
        "BATCH_SIZE = 64\n",
        "\n",
        "# Loss and optimizer\n",
        "criterion = torch.nn.CrossEntropyLoss()\n",
        "\n",
        "def _train(model, optimizer, train_dl):\n",
        "    losses = []\n",
        "    rtn_preds = []\n",
        "    rtn_labels = []\n",
        "    model.train()\n",
        "    for images, labels in train_dl:\n",
        "        images = images.to(DEVICE)\n",
        "        labels = labels.to(DEVICE)\n",
        "        # print(images.shape, labels.shape)\n",
        "        # Forward pass\n",
        "        outputs = model(images)\n",
        "        # print(outputs.shape)\n",
        "        loss = criterion(outputs, labels)\n",
        "        \n",
        "        predicted = torch.argmax(outputs, dim=1).long()\n",
        "        \n",
        "        rtn_preds.extend(predicted.detach().cpu().numpy())\n",
        "        rtn_labels.extend(labels.detach().cpu().numpy())\n",
        "        losses.append(loss.item())\n",
        "        \n",
        "        optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        \n",
        "    return losses, rtn_labels, rtn_preds\n",
        "\n",
        "def train(model, learning_rate, train_dl, val_dl, epochs, log_path: str):\n",
        "    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)\n",
        "    scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.9)\n",
        "\n",
        "    for epoch in range(epochs):\n",
        "        losses, rtn_labels, rtn_preds = _train(model, optimizer, train_dl)\n",
        "            \n",
        "        train_acc = (np.array(rtn_preds) == np.array(rtn_labels)).sum() / len(rtn_labels)\n",
        "        \n",
        "        val_loss, val_acc, val_labels, val_preds = evaluate(model, val_dl, testing=False)\n",
        "        rtn_preds.extend(np.array(val_preds))\n",
        "        rtn_labels.extend(np.array(val_labels))\n",
        "        \n",
        "        scheduler.step()\n",
        "            \n",
        "        print ('Epoch [{}/{}], Training Loss: {:.4f}, Train Accuracy: {:.4f}' \n",
        "                      .format(epoch+1, epochs, sum(losses) / len(losses), train_acc))\n",
        "        print ('Epoch [{}/{}], Validation Loss: {:.4f}, Validation Accuracy: {:.4f}' \n",
        "                      .format(epoch+1, epochs, val_loss, val_acc))\n",
        "        \n",
        "        if not exists(log_path):\n",
        "            os.mkdir(log_path)\n",
        "            \n",
        "        with open(log_path + \"train.log\", \"a\") as f:\n",
        "            if os.path.getsize(log_path + \"train.log\") <= 0:\n",
        "                f.write(\"epoch\\ttrain_acc\\ttrain_loss\\tval_acc\\tval_loss\\tlabels\\tpredictions\\n\")\n",
        "                \n",
        "            f.write(f\"{epoch}\\t{train_acc}\\t{sum(losses) / len(losses)}\\t{val_acc}\\t{val_loss}\\t{','.join([str(num) for num in rtn_labels])}\\t{','.join([str(num) for num in rtn_preds])}\\n\")\n",
        "    \n",
        "    # Start feeding validation set to the network\n",
        "    print()\n",
        "    print(\"Start training on validation set:\")\n",
        "    for epoch in range(epochs):\n",
        "        loss, acc, rtn_labels, rtn_preds = validate(model, optimizer, val_dl)\n",
        "        print ('Epoch [{}/{}], Train Loss: {:.4f}, Train on Validation Set Accuracy: {:.4f}' \n",
        "                      .format(epoch+1, epochs, loss, acc))\n",
        "    \n",
        "\n",
        "def validate(model, optimizer, val_dl, testing=True):\n",
        "    losses, rtn_labels, rtn_preds = _train(model, optimizer, val_dl)\n",
        "\n",
        "    return np.array(losses).mean(), (np.array(rtn_preds) == np.array(rtn_labels)).sum() / len(rtn_labels), rtn_labels, rtn_preds \n",
        "\n",
        "def train_find_best_lr(model, learning_rate, train_dl, val_dl, epochs=5):\n",
        "    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)\n",
        "    scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.9)\n",
        "\n",
        "    e_losses = []\n",
        "    model.train()\n",
        "    for epoch in range(epochs):\n",
        "        losses, _, _ = _train(model, optimizer, train_dl)\n",
        "            \n",
        "        val_loss, val_acc, val_labels, val_preds = evaluate(model, val_dl, testing=False)\n",
        "        \n",
        "        scheduler.step()\n",
        "        \n",
        "        e_losses.append(np.array(losses).mean())\n",
        "    \n",
        "    return np.array(e_losses).mean()\n",
        "\n",
        "\n",
        "def evaluate(model, val_dl, log_path = '', testing=True):\n",
        "    # if testing:\n",
        "    #     plt.figure(figsize=(50, 30))\n",
        "    \n",
        "    with torch.no_grad():\n",
        "        if testing:\n",
        "            model.eval()\n",
        "            \n",
        "        correct = 0\n",
        "        total = 0\n",
        "        rtn_preds = []\n",
        "        rtn_labels = []\n",
        "        rtn_losses = []\n",
        "        i = 0\n",
        "        for images, labels in val_dl:\n",
        "            images = images.to(DEVICE)\n",
        "            labels = labels.to(DEVICE)\n",
        "            outputs = model(images)\n",
        "            loss = criterion(outputs, labels)\n",
        "            \n",
        "            # print(outputs[0])\n",
        "            probabs = nn.functional.softmax(outputs, dim=1)\n",
        "            predicted = torch.argmax(outputs, dim=1).long()\n",
        "            # print(predicted)\n",
        "            total += labels.shape[0]\n",
        "            correct += (predicted == labels).sum().item()\n",
        "\n",
        "            rtn_preds.extend(predicted.detach().cpu().numpy())\n",
        "            rtn_labels.extend(labels.detach().cpu().numpy())\n",
        "            rtn_losses.append(loss.detach().cpu().item())\n",
        "            \n",
        "            if not testing:\n",
        "                continue\n",
        "            \n",
        "            if i > 16:\n",
        "                continue\n",
        "            \n",
        "            if not exists(log_path + '/test-images'):\n",
        "                os.mkdir(log_path + '/test-images')\n",
        "            \n",
        "            for ind, pred in enumerate(predicted):\n",
        "                if i > 16:\n",
        "                    break\n",
        "            \n",
        "                if predicted[ind] == labels[ind]:\n",
        "                    continue\n",
        "                \n",
        "                plt.title(\"Probab: \" + str(round(probabs[ind][pred].item() * 100) / 100) + \" P: \" + CLASS_LABELS[str(pred.item())] + \", A: \" + CLASS_LABELS[str(labels[ind].cpu().item())])\n",
        "                \n",
        "                subtitle = ''\n",
        "                top2 = probabs[ind].topk(2)\n",
        "                for index in range(2):\n",
        "                    subtitle += CLASS_LABELS[str(top2.indices[index].item())] +  \" : \" + str(round(top2.values[index].item() * 100) / 100) + ' '\n",
        "                plt.suptitle(subtitle)\n",
        "                \n",
        "                plt.imshow(images[ind].mul_(0.5).add_(0.5).detach().cpu().numpy().transpose(1, 2, 0))\n",
        "                plt.savefig(log_path + '/test-images/' + str(i) + '.png', bbox_inches='tight')\n",
        "                # plt.show()\n",
        "                i += 1\n",
        "            \n",
        "        \n",
        "        if testing:\n",
        "            if not exists(log_path):\n",
        "                os.mkdir(log_path)\n",
        "            \n",
        "            with open(log_path + \"test.log\", \"a\") as f:\n",
        "                if os.path.getsize(log_path + \"test.log\") <= 0:\n",
        "                    f.write(\"test_acc\\ttest_loss\\tlabels\\tpredictions\\n\")\n",
        "                    \n",
        "                f.write(f\"{correct / total}\\t{np.array(rtn_losses).mean()}\\t{','.join([str(num) for num in rtn_labels])}\\t{','.join([str(num) for num in rtn_preds])}\\n\")\n",
        "            \n",
        "            print('Accuracy of the network on the', total ,'validation images: {} %'.format(100 * correct / total))\n",
        "\n",
        "    return np.array(rtn_losses).mean(), correct / total, rtn_labels, rtn_preds\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### Setup model, data augmentation and dataloader"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 327,
          "referenced_widgets": [
            "76a29a2444f24315864aeda040b653fe",
            "0842aafc1f9d4cf4bbf20cba117217e0",
            "14492847902143c097725bf465fbb815",
            "7ef89c79720f4631988e416021092ca1",
            "448789856cf046e6af46922737d85347",
            "1557bf48e4d249b1a4ecb6431ec5d6c3",
            "320d78eb882b4c24a817fcf32f3cf879",
            "987334a6e9d24d088d10dd1611fddc55",
            "a8f79e1e5c344ee8831812a388256e40",
            "1881f4ef3f1641ae9135df0b6cc3dd20",
            "fa31d6529bd54739a1cc1584853227f2",
            "922f0488b3ff4c16a76319cdd9ef9bc0",
            "e189a18b60434a7c90b9c411dcc3fb48",
            "4c9c95a8ee3949eaa55e451bacebe0df",
            "d26a93f1f286432baedce846789aad66",
            "a8e7551243d14e9ba6a4553ac7bd98a6",
            "4d70108e3d2248eb9cf863a76c5e713f",
            "3c2a86250e29410d904202fb8411c6b5",
            "53b47c9f4de64404b1422f9a88869e5c",
            "cd937a4fc493428abbb4accbeb883fd5",
            "2707b8d3635f4469815e347c561955a9",
            "7d4af37e834b4ebb968e23d4147ad117"
          ]
        },
        "id": "8m2kvsWg1HXT",
        "outputId": "44d948ac-444b-4c12-881d-2d4472741ffb"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<__main__.CustomDataModule at 0x260d06abbe0>"
            ]
          },
          "execution_count": 27,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# 15 339 total images in label.txt\n",
        "LOG_PATH = 'logs/resnet18-e30-oversampling/'\n",
        "EPOCHS = 30\n",
        "\n",
        "facial_model = FacialClassificationTL(in_channels=3, requires_grad=True, pretrained=True).to(DEVICE)\n",
        "# facial_model = FacialClassification(in_channels=3).to(DEVICE)\n",
        "\n",
        "#resnet18 mean and std\n",
        "mean = [0.485, 0.456, 0.406]\n",
        "std = [0.229, 0.224, 0.225]\n",
        "\n",
        "data_module = CustomDataModule(\n",
        "    train_transforms=transforms.Compose([\n",
        "            transforms.ToPILImage(),\n",
        "            transforms.Resize((100, 100)),\n",
        "            transforms.ColorJitter(),\n",
        "            transforms.RandomHorizontalFlip(0.5),\n",
        "            transforms.RandomRotation(degrees=(-90, 90)),\n",
        "            transforms.RandomVerticalFlip(0.5),\n",
        "            transforms.ToTensor(),\n",
        "            transforms.Normalize(mean, std)]),\n",
        "    test_transforms=transforms.Compose([\n",
        "            transforms.ToPILImage(),\n",
        "            transforms.Resize((100, 100)),\n",
        "            transforms.ToTensor(),\n",
        "            transforms.Normalize(mean, std)]),\n",
        ")\n",
        "\n",
        "data_module.setup(\"fit\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### Find optimal LR"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {},
      "outputs": [],
      "source": [
        "# def find_best_lr():\n",
        "#     lrs = [0.01, 0.005, 0.003, 0.001, 0.0005, 0.0003, 0.0001]\n",
        "    \n",
        "#     model = FacialClassificationTL(in_channels=3, requires_grad=True, pretrained=True).to(DEVICE)\n",
        "    \n",
        "#     losses = []\n",
        "#     for exper_lr in lrs:\n",
        "#         loss = train_find_best_lr(model, learning_rate=exper_lr, train_dl=data_module.train_dataloader(), val_dl=data_module.val_dataloader(), epochs=1)\n",
        "        \n",
        "#         losses.append(loss)\n",
        "        \n",
        "#         print('Done:', exper_lr)\n",
        "        \n",
        "#     return np.array(lrs), np.array(losses)\n",
        "    \n",
        "# lrs, losses = find_best_lr()\n",
        "\n",
        "# plt.plot(lrs, losses)\n",
        "# plt.ylabel('Loss')\n",
        "# plt.xlabel('Learning Rate')\n",
        "# plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "The graph above shows that 0.001 is the optimal LR since when training we also reduce the LR with ExponentialLR."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### Train the model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch [1/30], Training Loss: 1.5331, Train Accuracy: 0.4220\n",
            "Epoch [1/30], Validation Loss: 1.6223, Validation Accuracy: 0.4463\n",
            "Epoch [2/30], Training Loss: 1.1945, Train Accuracy: 0.5548\n",
            "Epoch [2/30], Validation Loss: 1.3915, Validation Accuracy: 0.5163\n",
            "Epoch [3/30], Training Loss: 1.0451, Train Accuracy: 0.6141\n",
            "Epoch [3/30], Validation Loss: 1.4500, Validation Accuracy: 0.5081\n",
            "Epoch [4/30], Training Loss: 0.9226, Train Accuracy: 0.6605\n",
            "Epoch [4/30], Validation Loss: 1.3567, Validation Accuracy: 0.5505\n",
            "Epoch [5/30], Training Loss: 0.8207, Train Accuracy: 0.7011\n",
            "Epoch [5/30], Validation Loss: 1.2617, Validation Accuracy: 0.5977\n",
            "Epoch [6/30], Training Loss: 0.7274, Train Accuracy: 0.7348\n",
            "Epoch [6/30], Validation Loss: 1.1978, Validation Accuracy: 0.6059\n",
            "Epoch [7/30], Training Loss: 0.6637, Train Accuracy: 0.7569\n",
            "Epoch [7/30], Validation Loss: 1.1505, Validation Accuracy: 0.6059\n",
            "Epoch [8/30], Training Loss: 0.6082, Train Accuracy: 0.7774\n",
            "Epoch [8/30], Validation Loss: 1.1174, Validation Accuracy: 0.6433\n",
            "Epoch [9/30], Training Loss: 0.5371, Train Accuracy: 0.8047\n",
            "Epoch [9/30], Validation Loss: 1.1350, Validation Accuracy: 0.6629\n",
            "Epoch [10/30], Training Loss: 0.4823, Train Accuracy: 0.8232\n",
            "Epoch [10/30], Validation Loss: 0.9537, Validation Accuracy: 0.6906\n",
            "Epoch [11/30], Training Loss: 0.4497, Train Accuracy: 0.8355\n",
            "Epoch [11/30], Validation Loss: 1.0551, Validation Accuracy: 0.6661\n",
            "Epoch [12/30], Training Loss: 0.4083, Train Accuracy: 0.8492\n",
            "Epoch [12/30], Validation Loss: 0.9798, Validation Accuracy: 0.7003\n",
            "Epoch [13/30], Training Loss: 0.3764, Train Accuracy: 0.8628\n",
            "Epoch [13/30], Validation Loss: 1.0360, Validation Accuracy: 0.7052\n",
            "Epoch [14/30], Training Loss: 0.3372, Train Accuracy: 0.8787\n",
            "Epoch [14/30], Validation Loss: 1.0385, Validation Accuracy: 0.7264\n",
            "Epoch [15/30], Training Loss: 0.3118, Train Accuracy: 0.8877\n",
            "Epoch [15/30], Validation Loss: 1.0530, Validation Accuracy: 0.7199\n",
            "Epoch [16/30], Training Loss: 0.2920, Train Accuracy: 0.8932\n",
            "Epoch [16/30], Validation Loss: 1.0546, Validation Accuracy: 0.7101\n",
            "Epoch [17/30], Training Loss: 0.2685, Train Accuracy: 0.9025\n",
            "Epoch [17/30], Validation Loss: 0.9362, Validation Accuracy: 0.7313\n",
            "Epoch [18/30], Training Loss: 0.2539, Train Accuracy: 0.9061\n",
            "Epoch [18/30], Validation Loss: 0.9938, Validation Accuracy: 0.7182\n",
            "Epoch [19/30], Training Loss: 0.2354, Train Accuracy: 0.9157\n",
            "Epoch [19/30], Validation Loss: 1.0494, Validation Accuracy: 0.7280\n",
            "Epoch [20/30], Training Loss: 0.2211, Train Accuracy: 0.9191\n",
            "Epoch [20/30], Validation Loss: 1.0527, Validation Accuracy: 0.7248\n",
            "Epoch [21/30], Training Loss: 0.2107, Train Accuracy: 0.9241\n",
            "Epoch [21/30], Validation Loss: 0.9855, Validation Accuracy: 0.7524\n",
            "Epoch [22/30], Training Loss: 0.1995, Train Accuracy: 0.9285\n",
            "Epoch [22/30], Validation Loss: 0.9921, Validation Accuracy: 0.7329\n"
          ]
        },
        {
          "ename": "KeyboardInterrupt",
          "evalue": "",
          "output_type": "error",
          "traceback": [
            "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_10336/224854917.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mtrain\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfacial_model\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlearning_rate\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m0.001\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mepochs\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mEPOCHS\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtrain_dl\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mdata_module\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtrain_dataloader\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mval_dl\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mdata_module\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mval_dataloader\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlog_path\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mLOG_PATH\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;31m# facial_model.load_state_dict(torch.load('./checkpoints/resnet18-requires-grad-20ep.pt'))\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
            "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_10336/3001538493.py\u001b[0m in \u001b[0;36mtrain\u001b[1;34m(model, learning_rate, train_dl, val_dl, epochs, log_path)\u001b[0m\n\u001b[0;32m     36\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     37\u001b[0m     \u001b[1;32mfor\u001b[0m \u001b[0mepoch\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mepochs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 38\u001b[1;33m         \u001b[0mlosses\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrtn_labels\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrtn_preds\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_train\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0moptimizer\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtrain_dl\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     39\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     40\u001b[0m         \u001b[0mtrain_acc\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrtn_preds\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m==\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrtn_labels\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msum\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m/\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrtn_labels\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
            "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_10336/3001538493.py\u001b[0m in \u001b[0;36m_train\u001b[1;34m(model, optimizer, train_dl)\u001b[0m\n\u001b[0;32m     10\u001b[0m     \u001b[0mrtn_labels\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     11\u001b[0m     \u001b[0mmodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtrain\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 12\u001b[1;33m     \u001b[1;32mfor\u001b[0m \u001b[0mimages\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlabels\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mtrain_dl\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     13\u001b[0m         \u001b[0mimages\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mimages\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mto\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mDEVICE\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     14\u001b[0m         \u001b[0mlabels\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mlabels\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mto\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mDEVICE\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
            "\u001b[1;32mc:\\Users\\cseak\\anaconda3\\lib\\site-packages\\torch\\utils\\data\\dataloader.py\u001b[0m in \u001b[0;36m__next__\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m    519\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_sampler_iter\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    520\u001b[0m                 \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_reset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 521\u001b[1;33m             \u001b[0mdata\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_next_data\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    522\u001b[0m             \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_num_yielded\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    523\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_dataset_kind\u001b[0m \u001b[1;33m==\u001b[0m \u001b[0m_DatasetKind\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mIterable\u001b[0m \u001b[1;32mand\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m\\\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
            "\u001b[1;32mc:\\Users\\cseak\\anaconda3\\lib\\site-packages\\torch\\utils\\data\\dataloader.py\u001b[0m in \u001b[0;36m_next_data\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m    559\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0m_next_data\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    560\u001b[0m         \u001b[0mindex\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_next_index\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# may raise StopIteration\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 561\u001b[1;33m         \u001b[0mdata\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_dataset_fetcher\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfetch\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mindex\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# may raise StopIteration\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    562\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_pin_memory\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    563\u001b[0m             \u001b[0mdata\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_utils\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpin_memory\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpin_memory\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
            "\u001b[1;32mc:\\Users\\cseak\\anaconda3\\lib\\site-packages\\torch\\utils\\data\\_utils\\fetch.py\u001b[0m in \u001b[0;36mfetch\u001b[1;34m(self, possibly_batched_index)\u001b[0m\n\u001b[0;32m     47\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mfetch\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpossibly_batched_index\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     48\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mauto_collation\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 49\u001b[1;33m             \u001b[0mdata\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0midx\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0midx\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mpossibly_batched_index\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     50\u001b[0m         \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     51\u001b[0m             \u001b[0mdata\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mpossibly_batched_index\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
            "\u001b[1;32mc:\\Users\\cseak\\anaconda3\\lib\\site-packages\\torch\\utils\\data\\_utils\\fetch.py\u001b[0m in \u001b[0;36m<listcomp>\u001b[1;34m(.0)\u001b[0m\n\u001b[0;32m     47\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mfetch\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpossibly_batched_index\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     48\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mauto_collation\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 49\u001b[1;33m             \u001b[0mdata\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0midx\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0midx\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mpossibly_batched_index\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     50\u001b[0m         \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     51\u001b[0m             \u001b[0mdata\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mpossibly_batched_index\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
            "\u001b[1;32mc:\\Users\\cseak\\anaconda3\\lib\\site-packages\\torch\\utils\\data\\dataset.py\u001b[0m in \u001b[0;36m__getitem__\u001b[1;34m(self, idx)\u001b[0m\n\u001b[0;32m    361\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0midx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlist\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    362\u001b[0m             \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mindices\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[1;32min\u001b[0m \u001b[0midx\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 363\u001b[1;33m         \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mindices\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0midx\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    364\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    365\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0m__len__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
            "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_10336/3619815827.py\u001b[0m in \u001b[0;36m__getitem__\u001b[1;34m(self, idx)\u001b[0m\n\u001b[0;32m     19\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0m__getitem__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0midx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     20\u001b[0m         \u001b[0mobj\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0miloc\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0midx\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 21\u001b[1;33m         \u001b[0mimage\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mload_image\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mimg_path\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mobj\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'path'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     22\u001b[0m         \u001b[0mlabel\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mobj\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'label'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     23\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
            "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_10336/86990008.py\u001b[0m in \u001b[0;36mload_image\u001b[1;34m(path)\u001b[0m\n\u001b[0;32m     15\u001b[0m     \u001b[0mimg\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mload\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     16\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 17\u001b[1;33m     \u001b[1;32mreturn\u001b[0m \u001b[0mtransforms\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mToTensor\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mimg\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     18\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     19\u001b[0m \u001b[1;31m# https://pytorch.org/tutorials/beginner/transfer_learning_tutorial.html\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
            "\u001b[1;32mc:\\Users\\cseak\\anaconda3\\lib\\site-packages\\torchvision\\transforms\\transforms.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, pic)\u001b[0m\n\u001b[0;32m     96\u001b[0m             \u001b[0mTensor\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mConverted\u001b[0m \u001b[0mimage\u001b[0m\u001b[1;33m.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     97\u001b[0m         \"\"\"\n\u001b[1;32m---> 98\u001b[1;33m         \u001b[1;32mreturn\u001b[0m \u001b[0mF\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mto_tensor\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpic\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     99\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    100\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0m__repr__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
            "\u001b[1;32mc:\\Users\\cseak\\anaconda3\\lib\\site-packages\\torchvision\\transforms\\functional.py\u001b[0m in \u001b[0;36mto_tensor\u001b[1;34m(pic)\u001b[0m\n\u001b[0;32m    146\u001b[0m     \u001b[0mimg\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mimg\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mview\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpic\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msize\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpic\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msize\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpic\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mgetbands\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    147\u001b[0m     \u001b[1;31m# put it from HWC to CHW format\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 148\u001b[1;33m     \u001b[0mimg\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mimg\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpermute\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcontiguous\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    149\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mimg\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtorch\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mByteTensor\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    150\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[0mimg\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mto\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdtype\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mdefault_float_dtype\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdiv\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m255\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
            "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ],
      "source": [
        "train(facial_model, learning_rate=0.001, epochs=EPOCHS, train_dl=data_module.train_dataloader(), val_dl=data_module.val_dataloader(), log_path=LOG_PATH)\n",
        "\n",
        "# facial_model.load_state_dict(torch.load('./checkpoints/resnet18-requires-grad-20ep.pt'))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### test the model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Accuracy of the network on the 3068 validation images: 72.6857887874837 %\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "'1'"
            ]
          },
          "execution_count": 14,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "image/svg+xml": "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>\r\n<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\r\n  \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\r\n<svg height=\"277.318125pt\" version=\"1.1\" viewBox=\"0 0 258.3975 277.318125\" width=\"258.3975pt\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\r\n <metadata>\r\n  <rdf:RDF xmlns:cc=\"http://creativecommons.org/ns#\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">\r\n   <cc:Work>\r\n    <dc:type rdf:resource=\"http://purl.org/dc/dcmitype/StillImage\"/>\r\n    <dc:date>2022-07-07T00:38:35.728499</dc:date>\r\n    <dc:format>image/svg+xml</dc:format>\r\n    <dc:creator>\r\n     <cc:Agent>\r\n      <dc:title>Matplotlib v3.4.3, https://matplotlib.org/</dc:title>\r\n     </cc:Agent>\r\n    </dc:creator>\r\n   </cc:Work>\r\n  </rdf:RDF>\r\n </metadata>\r\n <defs>\r\n  <style type=\"text/css\">*{stroke-linecap:butt;stroke-linejoin:round;}</style>\r\n </defs>\r\n <g id=\"figure_1\">\r\n  <g id=\"patch_1\">\r\n   <path d=\"M 0 277.318125 \r\nL 258.3975 277.318125 \r\nL 258.3975 0 \r\nL 0 0 \r\nz\r\n\"/>\r\n  </g>\r\n  <g id=\"axes_1\">\r\n   <g id=\"patch_2\">\r\n    <path d=\"M 26.925 253.44 \r\nL 244.365 253.44 \r\nL 244.365 36 \r\nL 26.925 36 \r\nz\r\n\"/>\r\n   </g>\r\n   <g clip-path=\"url(#p9dd0c0a641)\">\r\n    <image height=\"218\" id=\"image37f8d49f3e\" transform=\"scale(1 -1)translate(0 -218)\" width=\"218\" x=\"27\" xlink:href=\"data:image/png;base64,\r\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\" y=\"-35.318125\"/>\r\n   </g>\r\n   <g id=\"matplotlib.axis_1\">\r\n    <g id=\"xtick_1\">\r\n     <g id=\"line2d_1\">\r\n      <defs>\r\n       <path d=\"M 0 0 \r\nL 0 3.5 \r\n\" id=\"m925c783b75\" style=\"stroke:#ffffff;stroke-width:0.8;\"/>\r\n      </defs>\r\n      <g>\r\n       <use style=\"fill:#ffffff;stroke:#ffffff;stroke-width:0.8;\" x=\"28.0122\" xlink:href=\"#m925c783b75\" y=\"253.44\"/>\r\n      </g>\r\n     </g>\r\n     <g id=\"text_1\">\r\n      <!-- 0 -->\r\n      <g style=\"fill:#ffffff;\" transform=\"translate(24.83095 268.038437)scale(0.1 -0.1)\">\r\n       <defs>\r\n        <path d=\"M 2034 4250 \r\nQ 1547 4250 1301 3770 \r\nQ 1056 3291 1056 2328 \r\nQ 1056 1369 1301 889 \r\nQ 1547 409 2034 409 \r\nQ 2525 409 2770 889 \r\nQ 3016 1369 3016 2328 \r\nQ 3016 3291 2770 3770 \r\nQ 2525 4250 2034 4250 \r\nz\r\nM 2034 4750 \r\nQ 2819 4750 3233 4129 \r\nQ 3647 3509 3647 2328 \r\nQ 3647 1150 3233 529 \r\nQ 2819 -91 2034 -91 \r\nQ 1250 -91 836 529 \r\nQ 422 1150 422 2328 \r\nQ 422 3509 836 4129 \r\nQ 1250 4750 2034 4750 \r\nz\r\n\" id=\"DejaVuSans-30\" transform=\"scale(0.015625)\"/>\r\n       </defs>\r\n       <use xlink:href=\"#DejaVuSans-30\"/>\r\n      </g>\r\n     </g>\r\n    </g>\r\n    <g id=\"xtick_2\">\r\n     <g id=\"line2d_2\">\r\n      <g>\r\n       <use style=\"fill:#ffffff;stroke:#ffffff;stroke-width:0.8;\" x=\"71.5002\" xlink:href=\"#m925c783b75\" y=\"253.44\"/>\r\n      </g>\r\n     </g>\r\n     <g id=\"text_2\">\r\n      <!-- 20 -->\r\n      <g style=\"fill:#ffffff;\" transform=\"translate(65.1377 268.038437)scale(0.1 -0.1)\">\r\n       <defs>\r\n        <path d=\"M 1228 531 \r\nL 3431 531 \r\nL 3431 0 \r\nL 469 0 \r\nL 469 531 \r\nQ 828 903 1448 1529 \r\nQ 2069 2156 2228 2338 \r\nQ 2531 2678 2651 2914 \r\nQ 2772 3150 2772 3378 \r\nQ 2772 3750 2511 3984 \r\nQ 2250 4219 1831 4219 \r\nQ 1534 4219 1204 4116 \r\nQ 875 4013 500 3803 \r\nL 500 4441 \r\nQ 881 4594 1212 4672 \r\nQ 1544 4750 1819 4750 \r\nQ 2544 4750 2975 4387 \r\nQ 3406 4025 3406 3419 \r\nQ 3406 3131 3298 2873 \r\nQ 3191 2616 2906 2266 \r\nQ 2828 2175 2409 1742 \r\nQ 1991 1309 1228 531 \r\nz\r\n\" id=\"DejaVuSans-32\" transform=\"scale(0.015625)\"/>\r\n       </defs>\r\n       <use xlink:href=\"#DejaVuSans-32\"/>\r\n       <use x=\"63.623047\" xlink:href=\"#DejaVuSans-30\"/>\r\n      </g>\r\n     </g>\r\n    </g>\r\n    <g id=\"xtick_3\">\r\n     <g id=\"line2d_3\">\r\n      <g>\r\n       <use style=\"fill:#ffffff;stroke:#ffffff;stroke-width:0.8;\" x=\"114.9882\" xlink:href=\"#m925c783b75\" y=\"253.44\"/>\r\n      </g>\r\n     </g>\r\n     <g id=\"text_3\">\r\n      <!-- 40 -->\r\n      <g style=\"fill:#ffffff;\" transform=\"translate(108.6257 268.038437)scale(0.1 -0.1)\">\r\n       <defs>\r\n        <path d=\"M 2419 4116 \r\nL 825 1625 \r\nL 2419 1625 \r\nL 2419 4116 \r\nz\r\nM 2253 4666 \r\nL 3047 4666 \r\nL 3047 1625 \r\nL 3713 1625 \r\nL 3713 1100 \r\nL 3047 1100 \r\nL 3047 0 \r\nL 2419 0 \r\nL 2419 1100 \r\nL 313 1100 \r\nL 313 1709 \r\nL 2253 4666 \r\nz\r\n\" id=\"DejaVuSans-34\" transform=\"scale(0.015625)\"/>\r\n       </defs>\r\n       <use xlink:href=\"#DejaVuSans-34\"/>\r\n       <use x=\"63.623047\" xlink:href=\"#DejaVuSans-30\"/>\r\n      </g>\r\n     </g>\r\n    </g>\r\n    <g id=\"xtick_4\">\r\n     <g id=\"line2d_4\">\r\n      <g>\r\n       <use style=\"fill:#ffffff;stroke:#ffffff;stroke-width:0.8;\" x=\"158.4762\" xlink:href=\"#m925c783b75\" y=\"253.44\"/>\r\n      </g>\r\n     </g>\r\n     <g id=\"text_4\">\r\n      <!-- 60 -->\r\n      <g style=\"fill:#ffffff;\" transform=\"translate(152.1137 268.038437)scale(0.1 -0.1)\">\r\n       <defs>\r\n        <path d=\"M 2113 2584 \r\nQ 1688 2584 1439 2293 \r\nQ 1191 2003 1191 1497 \r\nQ 1191 994 1439 701 \r\nQ 1688 409 2113 409 \r\nQ 2538 409 2786 701 \r\nQ 3034 994 3034 1497 \r\nQ 3034 2003 2786 2293 \r\nQ 2538 2584 2113 2584 \r\nz\r\nM 3366 4563 \r\nL 3366 3988 \r\nQ 3128 4100 2886 4159 \r\nQ 2644 4219 2406 4219 \r\nQ 1781 4219 1451 3797 \r\nQ 1122 3375 1075 2522 \r\nQ 1259 2794 1537 2939 \r\nQ 1816 3084 2150 3084 \r\nQ 2853 3084 3261 2657 \r\nQ 3669 2231 3669 1497 \r\nQ 3669 778 3244 343 \r\nQ 2819 -91 2113 -91 \r\nQ 1303 -91 875 529 \r\nQ 447 1150 447 2328 \r\nQ 447 3434 972 4092 \r\nQ 1497 4750 2381 4750 \r\nQ 2619 4750 2861 4703 \r\nQ 3103 4656 3366 4563 \r\nz\r\n\" id=\"DejaVuSans-36\" transform=\"scale(0.015625)\"/>\r\n       </defs>\r\n       <use xlink:href=\"#DejaVuSans-36\"/>\r\n       <use x=\"63.623047\" xlink:href=\"#DejaVuSans-30\"/>\r\n      </g>\r\n     </g>\r\n    </g>\r\n    <g id=\"xtick_5\">\r\n     <g id=\"line2d_5\">\r\n      <g>\r\n       <use style=\"fill:#ffffff;stroke:#ffffff;stroke-width:0.8;\" x=\"201.9642\" xlink:href=\"#m925c783b75\" y=\"253.44\"/>\r\n      </g>\r\n     </g>\r\n     <g id=\"text_5\">\r\n      <!-- 80 -->\r\n      <g style=\"fill:#ffffff;\" transform=\"translate(195.6017 268.038437)scale(0.1 -0.1)\">\r\n       <defs>\r\n        <path d=\"M 2034 2216 \r\nQ 1584 2216 1326 1975 \r\nQ 1069 1734 1069 1313 \r\nQ 1069 891 1326 650 \r\nQ 1584 409 2034 409 \r\nQ 2484 409 2743 651 \r\nQ 3003 894 3003 1313 \r\nQ 3003 1734 2745 1975 \r\nQ 2488 2216 2034 2216 \r\nz\r\nM 1403 2484 \r\nQ 997 2584 770 2862 \r\nQ 544 3141 544 3541 \r\nQ 544 4100 942 4425 \r\nQ 1341 4750 2034 4750 \r\nQ 2731 4750 3128 4425 \r\nQ 3525 4100 3525 3541 \r\nQ 3525 3141 3298 2862 \r\nQ 3072 2584 2669 2484 \r\nQ 3125 2378 3379 2068 \r\nQ 3634 1759 3634 1313 \r\nQ 3634 634 3220 271 \r\nQ 2806 -91 2034 -91 \r\nQ 1263 -91 848 271 \r\nQ 434 634 434 1313 \r\nQ 434 1759 690 2068 \r\nQ 947 2378 1403 2484 \r\nz\r\nM 1172 3481 \r\nQ 1172 3119 1398 2916 \r\nQ 1625 2713 2034 2713 \r\nQ 2441 2713 2670 2916 \r\nQ 2900 3119 2900 3481 \r\nQ 2900 3844 2670 4047 \r\nQ 2441 4250 2034 4250 \r\nQ 1625 4250 1398 4047 \r\nQ 1172 3844 1172 3481 \r\nz\r\n\" id=\"DejaVuSans-38\" transform=\"scale(0.015625)\"/>\r\n       </defs>\r\n       <use xlink:href=\"#DejaVuSans-38\"/>\r\n       <use x=\"63.623047\" xlink:href=\"#DejaVuSans-30\"/>\r\n      </g>\r\n     </g>\r\n    </g>\r\n   </g>\r\n   <g id=\"matplotlib.axis_2\">\r\n    <g id=\"ytick_1\">\r\n     <g id=\"line2d_6\">\r\n      <defs>\r\n       <path d=\"M 0 0 \r\nL -3.5 0 \r\n\" id=\"m3c3746e7cf\" style=\"stroke:#ffffff;stroke-width:0.8;\"/>\r\n      </defs>\r\n      <g>\r\n       <use style=\"fill:#ffffff;stroke:#ffffff;stroke-width:0.8;\" x=\"26.925\" xlink:href=\"#m3c3746e7cf\" y=\"37.0872\"/>\r\n      </g>\r\n     </g>\r\n     <g id=\"text_6\">\r\n      <!-- 0 -->\r\n      <g style=\"fill:#ffffff;\" transform=\"translate(13.5625 40.886419)scale(0.1 -0.1)\">\r\n       <use xlink:href=\"#DejaVuSans-30\"/>\r\n      </g>\r\n     </g>\r\n    </g>\r\n    <g id=\"ytick_2\">\r\n     <g id=\"line2d_7\">\r\n      <g>\r\n       <use style=\"fill:#ffffff;stroke:#ffffff;stroke-width:0.8;\" x=\"26.925\" xlink:href=\"#m3c3746e7cf\" y=\"80.5752\"/>\r\n      </g>\r\n     </g>\r\n     <g id=\"text_7\">\r\n      <!-- 20 -->\r\n      <g style=\"fill:#ffffff;\" transform=\"translate(7.2 84.374419)scale(0.1 -0.1)\">\r\n       <use xlink:href=\"#DejaVuSans-32\"/>\r\n       <use x=\"63.623047\" xlink:href=\"#DejaVuSans-30\"/>\r\n      </g>\r\n     </g>\r\n    </g>\r\n    <g id=\"ytick_3\">\r\n     <g id=\"line2d_8\">\r\n      <g>\r\n       <use style=\"fill:#ffffff;stroke:#ffffff;stroke-width:0.8;\" x=\"26.925\" xlink:href=\"#m3c3746e7cf\" y=\"124.0632\"/>\r\n      </g>\r\n     </g>\r\n     <g id=\"text_8\">\r\n      <!-- 40 -->\r\n      <g style=\"fill:#ffffff;\" transform=\"translate(7.2 127.862419)scale(0.1 -0.1)\">\r\n       <use xlink:href=\"#DejaVuSans-34\"/>\r\n       <use x=\"63.623047\" xlink:href=\"#DejaVuSans-30\"/>\r\n      </g>\r\n     </g>\r\n    </g>\r\n    <g id=\"ytick_4\">\r\n     <g id=\"line2d_9\">\r\n      <g>\r\n       <use style=\"fill:#ffffff;stroke:#ffffff;stroke-width:0.8;\" x=\"26.925\" xlink:href=\"#m3c3746e7cf\" y=\"167.5512\"/>\r\n      </g>\r\n     </g>\r\n     <g id=\"text_9\">\r\n      <!-- 60 -->\r\n      <g style=\"fill:#ffffff;\" transform=\"translate(7.2 171.350419)scale(0.1 -0.1)\">\r\n       <use xlink:href=\"#DejaVuSans-36\"/>\r\n       <use x=\"63.623047\" xlink:href=\"#DejaVuSans-30\"/>\r\n      </g>\r\n     </g>\r\n    </g>\r\n    <g id=\"ytick_5\">\r\n     <g id=\"line2d_10\">\r\n      <g>\r\n       <use style=\"fill:#ffffff;stroke:#ffffff;stroke-width:0.8;\" x=\"26.925\" xlink:href=\"#m3c3746e7cf\" y=\"211.0392\"/>\r\n      </g>\r\n     </g>\r\n     <g id=\"text_10\">\r\n      <!-- 80 -->\r\n      <g style=\"fill:#ffffff;\" transform=\"translate(7.2 214.838419)scale(0.1 -0.1)\">\r\n       <use xlink:href=\"#DejaVuSans-38\"/>\r\n       <use x=\"63.623047\" xlink:href=\"#DejaVuSans-30\"/>\r\n      </g>\r\n     </g>\r\n    </g>\r\n   </g>\r\n   <g id=\"patch_3\">\r\n    <path d=\"M 26.925 253.44 \r\nL 26.925 36 \r\n\" style=\"fill:none;stroke:#ffffff;stroke-linecap:square;stroke-linejoin:miter;stroke-width:0.8;\"/>\r\n   </g>\r\n   <g id=\"patch_4\">\r\n    <path d=\"M 244.365 253.44 \r\nL 244.365 36 \r\n\" style=\"fill:none;stroke:#ffffff;stroke-linecap:square;stroke-linejoin:miter;stroke-width:0.8;\"/>\r\n   </g>\r\n   <g id=\"patch_5\">\r\n    <path d=\"M 26.925 253.44 \r\nL 244.365 253.44 \r\n\" style=\"fill:none;stroke:#ffffff;stroke-linecap:square;stroke-linejoin:miter;stroke-width:0.8;\"/>\r\n   </g>\r\n   <g id=\"patch_6\">\r\n    <path d=\"M 26.925 36 \r\nL 244.365 36 \r\n\" style=\"fill:none;stroke:#ffffff;stroke-linecap:square;stroke-linejoin:miter;stroke-width:0.8;\"/>\r\n   </g>\r\n   <g id=\"text_11\">\r\n    <!-- Probab: 0.53 P: Sadness, A: Happiness -->\r\n    <g style=\"fill:#ffffff;\" transform=\"translate(20.0925 30)scale(0.12 -0.12)\">\r\n     <defs>\r\n      <path d=\"M 1259 4147 \r\nL 1259 2394 \r\nL 2053 2394 \r\nQ 2494 2394 2734 2622 \r\nQ 2975 2850 2975 3272 \r\nQ 2975 3691 2734 3919 \r\nQ 2494 4147 2053 4147 \r\nL 1259 4147 \r\nz\r\nM 628 4666 \r\nL 2053 4666 \r\nQ 2838 4666 3239 4311 \r\nQ 3641 3956 3641 3272 \r\nQ 3641 2581 3239 2228 \r\nQ 2838 1875 2053 1875 \r\nL 1259 1875 \r\nL 1259 0 \r\nL 628 0 \r\nL 628 4666 \r\nz\r\n\" id=\"DejaVuSans-50\" transform=\"scale(0.015625)\"/>\r\n      <path d=\"M 2631 2963 \r\nQ 2534 3019 2420 3045 \r\nQ 2306 3072 2169 3072 \r\nQ 1681 3072 1420 2755 \r\nQ 1159 2438 1159 1844 \r\nL 1159 0 \r\nL 581 0 \r\nL 581 3500 \r\nL 1159 3500 \r\nL 1159 2956 \r\nQ 1341 3275 1631 3429 \r\nQ 1922 3584 2338 3584 \r\nQ 2397 3584 2469 3576 \r\nQ 2541 3569 2628 3553 \r\nL 2631 2963 \r\nz\r\n\" id=\"DejaVuSans-72\" transform=\"scale(0.015625)\"/>\r\n      <path d=\"M 1959 3097 \r\nQ 1497 3097 1228 2736 \r\nQ 959 2375 959 1747 \r\nQ 959 1119 1226 758 \r\nQ 1494 397 1959 397 \r\nQ 2419 397 2687 759 \r\nQ 2956 1122 2956 1747 \r\nQ 2956 2369 2687 2733 \r\nQ 2419 3097 1959 3097 \r\nz\r\nM 1959 3584 \r\nQ 2709 3584 3137 3096 \r\nQ 3566 2609 3566 1747 \r\nQ 3566 888 3137 398 \r\nQ 2709 -91 1959 -91 \r\nQ 1206 -91 779 398 \r\nQ 353 888 353 1747 \r\nQ 353 2609 779 3096 \r\nQ 1206 3584 1959 3584 \r\nz\r\n\" id=\"DejaVuSans-6f\" transform=\"scale(0.015625)\"/>\r\n      <path d=\"M 3116 1747 \r\nQ 3116 2381 2855 2742 \r\nQ 2594 3103 2138 3103 \r\nQ 1681 3103 1420 2742 \r\nQ 1159 2381 1159 1747 \r\nQ 1159 1113 1420 752 \r\nQ 1681 391 2138 391 \r\nQ 2594 391 2855 752 \r\nQ 3116 1113 3116 1747 \r\nz\r\nM 1159 2969 \r\nQ 1341 3281 1617 3432 \r\nQ 1894 3584 2278 3584 \r\nQ 2916 3584 3314 3078 \r\nQ 3713 2572 3713 1747 \r\nQ 3713 922 3314 415 \r\nQ 2916 -91 2278 -91 \r\nQ 1894 -91 1617 61 \r\nQ 1341 213 1159 525 \r\nL 1159 0 \r\nL 581 0 \r\nL 581 4863 \r\nL 1159 4863 \r\nL 1159 2969 \r\nz\r\n\" id=\"DejaVuSans-62\" transform=\"scale(0.015625)\"/>\r\n      <path d=\"M 2194 1759 \r\nQ 1497 1759 1228 1600 \r\nQ 959 1441 959 1056 \r\nQ 959 750 1161 570 \r\nQ 1363 391 1709 391 \r\nQ 2188 391 2477 730 \r\nQ 2766 1069 2766 1631 \r\nL 2766 1759 \r\nL 2194 1759 \r\nz\r\nM 3341 1997 \r\nL 3341 0 \r\nL 2766 0 \r\nL 2766 531 \r\nQ 2569 213 2275 61 \r\nQ 1981 -91 1556 -91 \r\nQ 1019 -91 701 211 \r\nQ 384 513 384 1019 \r\nQ 384 1609 779 1909 \r\nQ 1175 2209 1959 2209 \r\nL 2766 2209 \r\nL 2766 2266 \r\nQ 2766 2663 2505 2880 \r\nQ 2244 3097 1772 3097 \r\nQ 1472 3097 1187 3025 \r\nQ 903 2953 641 2809 \r\nL 641 3341 \r\nQ 956 3463 1253 3523 \r\nQ 1550 3584 1831 3584 \r\nQ 2591 3584 2966 3190 \r\nQ 3341 2797 3341 1997 \r\nz\r\n\" id=\"DejaVuSans-61\" transform=\"scale(0.015625)\"/>\r\n      <path d=\"M 750 794 \r\nL 1409 794 \r\nL 1409 0 \r\nL 750 0 \r\nL 750 794 \r\nz\r\nM 750 3309 \r\nL 1409 3309 \r\nL 1409 2516 \r\nL 750 2516 \r\nL 750 3309 \r\nz\r\n\" id=\"DejaVuSans-3a\" transform=\"scale(0.015625)\"/>\r\n      <path id=\"DejaVuSans-20\" transform=\"scale(0.015625)\"/>\r\n      <path d=\"M 684 794 \r\nL 1344 794 \r\nL 1344 0 \r\nL 684 0 \r\nL 684 794 \r\nz\r\n\" id=\"DejaVuSans-2e\" transform=\"scale(0.015625)\"/>\r\n      <path d=\"M 691 4666 \r\nL 3169 4666 \r\nL 3169 4134 \r\nL 1269 4134 \r\nL 1269 2991 \r\nQ 1406 3038 1543 3061 \r\nQ 1681 3084 1819 3084 \r\nQ 2600 3084 3056 2656 \r\nQ 3513 2228 3513 1497 \r\nQ 3513 744 3044 326 \r\nQ 2575 -91 1722 -91 \r\nQ 1428 -91 1123 -41 \r\nQ 819 9 494 109 \r\nL 494 744 \r\nQ 775 591 1075 516 \r\nQ 1375 441 1709 441 \r\nQ 2250 441 2565 725 \r\nQ 2881 1009 2881 1497 \r\nQ 2881 1984 2565 2268 \r\nQ 2250 2553 1709 2553 \r\nQ 1456 2553 1204 2497 \r\nQ 953 2441 691 2322 \r\nL 691 4666 \r\nz\r\n\" id=\"DejaVuSans-35\" transform=\"scale(0.015625)\"/>\r\n      <path d=\"M 2597 2516 \r\nQ 3050 2419 3304 2112 \r\nQ 3559 1806 3559 1356 \r\nQ 3559 666 3084 287 \r\nQ 2609 -91 1734 -91 \r\nQ 1441 -91 1130 -33 \r\nQ 819 25 488 141 \r\nL 488 750 \r\nQ 750 597 1062 519 \r\nQ 1375 441 1716 441 \r\nQ 2309 441 2620 675 \r\nQ 2931 909 2931 1356 \r\nQ 2931 1769 2642 2001 \r\nQ 2353 2234 1838 2234 \r\nL 1294 2234 \r\nL 1294 2753 \r\nL 1863 2753 \r\nQ 2328 2753 2575 2939 \r\nQ 2822 3125 2822 3475 \r\nQ 2822 3834 2567 4026 \r\nQ 2313 4219 1838 4219 \r\nQ 1578 4219 1281 4162 \r\nQ 984 4106 628 3988 \r\nL 628 4550 \r\nQ 988 4650 1302 4700 \r\nQ 1616 4750 1894 4750 \r\nQ 2613 4750 3031 4423 \r\nQ 3450 4097 3450 3541 \r\nQ 3450 3153 3228 2886 \r\nQ 3006 2619 2597 2516 \r\nz\r\n\" id=\"DejaVuSans-33\" transform=\"scale(0.015625)\"/>\r\n      <path d=\"M 3425 4513 \r\nL 3425 3897 \r\nQ 3066 4069 2747 4153 \r\nQ 2428 4238 2131 4238 \r\nQ 1616 4238 1336 4038 \r\nQ 1056 3838 1056 3469 \r\nQ 1056 3159 1242 3001 \r\nQ 1428 2844 1947 2747 \r\nL 2328 2669 \r\nQ 3034 2534 3370 2195 \r\nQ 3706 1856 3706 1288 \r\nQ 3706 609 3251 259 \r\nQ 2797 -91 1919 -91 \r\nQ 1588 -91 1214 -16 \r\nQ 841 59 441 206 \r\nL 441 856 \r\nQ 825 641 1194 531 \r\nQ 1563 422 1919 422 \r\nQ 2459 422 2753 634 \r\nQ 3047 847 3047 1241 \r\nQ 3047 1584 2836 1778 \r\nQ 2625 1972 2144 2069 \r\nL 1759 2144 \r\nQ 1053 2284 737 2584 \r\nQ 422 2884 422 3419 \r\nQ 422 4038 858 4394 \r\nQ 1294 4750 2059 4750 \r\nQ 2388 4750 2728 4690 \r\nQ 3069 4631 3425 4513 \r\nz\r\n\" id=\"DejaVuSans-53\" transform=\"scale(0.015625)\"/>\r\n      <path d=\"M 2906 2969 \r\nL 2906 4863 \r\nL 3481 4863 \r\nL 3481 0 \r\nL 2906 0 \r\nL 2906 525 \r\nQ 2725 213 2448 61 \r\nQ 2172 -91 1784 -91 \r\nQ 1150 -91 751 415 \r\nQ 353 922 353 1747 \r\nQ 353 2572 751 3078 \r\nQ 1150 3584 1784 3584 \r\nQ 2172 3584 2448 3432 \r\nQ 2725 3281 2906 2969 \r\nz\r\nM 947 1747 \r\nQ 947 1113 1208 752 \r\nQ 1469 391 1925 391 \r\nQ 2381 391 2643 752 \r\nQ 2906 1113 2906 1747 \r\nQ 2906 2381 2643 2742 \r\nQ 2381 3103 1925 3103 \r\nQ 1469 3103 1208 2742 \r\nQ 947 2381 947 1747 \r\nz\r\n\" id=\"DejaVuSans-64\" transform=\"scale(0.015625)\"/>\r\n      <path d=\"M 3513 2113 \r\nL 3513 0 \r\nL 2938 0 \r\nL 2938 2094 \r\nQ 2938 2591 2744 2837 \r\nQ 2550 3084 2163 3084 \r\nQ 1697 3084 1428 2787 \r\nQ 1159 2491 1159 1978 \r\nL 1159 0 \r\nL 581 0 \r\nL 581 3500 \r\nL 1159 3500 \r\nL 1159 2956 \r\nQ 1366 3272 1645 3428 \r\nQ 1925 3584 2291 3584 \r\nQ 2894 3584 3203 3211 \r\nQ 3513 2838 3513 2113 \r\nz\r\n\" id=\"DejaVuSans-6e\" transform=\"scale(0.015625)\"/>\r\n      <path d=\"M 3597 1894 \r\nL 3597 1613 \r\nL 953 1613 \r\nQ 991 1019 1311 708 \r\nQ 1631 397 2203 397 \r\nQ 2534 397 2845 478 \r\nQ 3156 559 3463 722 \r\nL 3463 178 \r\nQ 3153 47 2828 -22 \r\nQ 2503 -91 2169 -91 \r\nQ 1331 -91 842 396 \r\nQ 353 884 353 1716 \r\nQ 353 2575 817 3079 \r\nQ 1281 3584 2069 3584 \r\nQ 2775 3584 3186 3129 \r\nQ 3597 2675 3597 1894 \r\nz\r\nM 3022 2063 \r\nQ 3016 2534 2758 2815 \r\nQ 2500 3097 2075 3097 \r\nQ 1594 3097 1305 2825 \r\nQ 1016 2553 972 2059 \r\nL 3022 2063 \r\nz\r\n\" id=\"DejaVuSans-65\" transform=\"scale(0.015625)\"/>\r\n      <path d=\"M 2834 3397 \r\nL 2834 2853 \r\nQ 2591 2978 2328 3040 \r\nQ 2066 3103 1784 3103 \r\nQ 1356 3103 1142 2972 \r\nQ 928 2841 928 2578 \r\nQ 928 2378 1081 2264 \r\nQ 1234 2150 1697 2047 \r\nL 1894 2003 \r\nQ 2506 1872 2764 1633 \r\nQ 3022 1394 3022 966 \r\nQ 3022 478 2636 193 \r\nQ 2250 -91 1575 -91 \r\nQ 1294 -91 989 -36 \r\nQ 684 19 347 128 \r\nL 347 722 \r\nQ 666 556 975 473 \r\nQ 1284 391 1588 391 \r\nQ 1994 391 2212 530 \r\nQ 2431 669 2431 922 \r\nQ 2431 1156 2273 1281 \r\nQ 2116 1406 1581 1522 \r\nL 1381 1569 \r\nQ 847 1681 609 1914 \r\nQ 372 2147 372 2553 \r\nQ 372 3047 722 3315 \r\nQ 1072 3584 1716 3584 \r\nQ 2034 3584 2315 3537 \r\nQ 2597 3491 2834 3397 \r\nz\r\n\" id=\"DejaVuSans-73\" transform=\"scale(0.015625)\"/>\r\n      <path d=\"M 750 794 \r\nL 1409 794 \r\nL 1409 256 \r\nL 897 -744 \r\nL 494 -744 \r\nL 750 256 \r\nL 750 794 \r\nz\r\n\" id=\"DejaVuSans-2c\" transform=\"scale(0.015625)\"/>\r\n      <path d=\"M 2188 4044 \r\nL 1331 1722 \r\nL 3047 1722 \r\nL 2188 4044 \r\nz\r\nM 1831 4666 \r\nL 2547 4666 \r\nL 4325 0 \r\nL 3669 0 \r\nL 3244 1197 \r\nL 1141 1197 \r\nL 716 0 \r\nL 50 0 \r\nL 1831 4666 \r\nz\r\n\" id=\"DejaVuSans-41\" transform=\"scale(0.015625)\"/>\r\n      <path d=\"M 628 4666 \r\nL 1259 4666 \r\nL 1259 2753 \r\nL 3553 2753 \r\nL 3553 4666 \r\nL 4184 4666 \r\nL 4184 0 \r\nL 3553 0 \r\nL 3553 2222 \r\nL 1259 2222 \r\nL 1259 0 \r\nL 628 0 \r\nL 628 4666 \r\nz\r\n\" id=\"DejaVuSans-48\" transform=\"scale(0.015625)\"/>\r\n      <path d=\"M 1159 525 \r\nL 1159 -1331 \r\nL 581 -1331 \r\nL 581 3500 \r\nL 1159 3500 \r\nL 1159 2969 \r\nQ 1341 3281 1617 3432 \r\nQ 1894 3584 2278 3584 \r\nQ 2916 3584 3314 3078 \r\nQ 3713 2572 3713 1747 \r\nQ 3713 922 3314 415 \r\nQ 2916 -91 2278 -91 \r\nQ 1894 -91 1617 61 \r\nQ 1341 213 1159 525 \r\nz\r\nM 3116 1747 \r\nQ 3116 2381 2855 2742 \r\nQ 2594 3103 2138 3103 \r\nQ 1681 3103 1420 2742 \r\nQ 1159 2381 1159 1747 \r\nQ 1159 1113 1420 752 \r\nQ 1681 391 2138 391 \r\nQ 2594 391 2855 752 \r\nQ 3116 1113 3116 1747 \r\nz\r\n\" id=\"DejaVuSans-70\" transform=\"scale(0.015625)\"/>\r\n      <path d=\"M 603 3500 \r\nL 1178 3500 \r\nL 1178 0 \r\nL 603 0 \r\nL 603 3500 \r\nz\r\nM 603 4863 \r\nL 1178 4863 \r\nL 1178 4134 \r\nL 603 4134 \r\nL 603 4863 \r\nz\r\n\" id=\"DejaVuSans-69\" transform=\"scale(0.015625)\"/>\r\n     </defs>\r\n     <use xlink:href=\"#DejaVuSans-50\"/>\r\n     <use x=\"58.552734\" xlink:href=\"#DejaVuSans-72\"/>\r\n     <use x=\"97.416016\" xlink:href=\"#DejaVuSans-6f\"/>\r\n     <use x=\"158.597656\" xlink:href=\"#DejaVuSans-62\"/>\r\n     <use x=\"222.074219\" xlink:href=\"#DejaVuSans-61\"/>\r\n     <use x=\"283.353516\" xlink:href=\"#DejaVuSans-62\"/>\r\n     <use x=\"346.830078\" xlink:href=\"#DejaVuSans-3a\"/>\r\n     <use x=\"380.521484\" xlink:href=\"#DejaVuSans-20\"/>\r\n     <use x=\"412.308594\" xlink:href=\"#DejaVuSans-30\"/>\r\n     <use x=\"475.931641\" xlink:href=\"#DejaVuSans-2e\"/>\r\n     <use x=\"507.71875\" xlink:href=\"#DejaVuSans-35\"/>\r\n     <use x=\"571.341797\" xlink:href=\"#DejaVuSans-33\"/>\r\n     <use x=\"634.964844\" xlink:href=\"#DejaVuSans-20\"/>\r\n     <use x=\"666.751953\" xlink:href=\"#DejaVuSans-50\"/>\r\n     <use x=\"727.054688\" xlink:href=\"#DejaVuSans-3a\"/>\r\n     <use x=\"760.746094\" xlink:href=\"#DejaVuSans-20\"/>\r\n     <use x=\"792.533203\" xlink:href=\"#DejaVuSans-53\"/>\r\n     <use x=\"856.009766\" xlink:href=\"#DejaVuSans-61\"/>\r\n     <use x=\"917.289062\" xlink:href=\"#DejaVuSans-64\"/>\r\n     <use x=\"980.765625\" xlink:href=\"#DejaVuSans-6e\"/>\r\n     <use x=\"1044.144531\" xlink:href=\"#DejaVuSans-65\"/>\r\n     <use x=\"1105.667969\" xlink:href=\"#DejaVuSans-73\"/>\r\n     <use x=\"1157.767578\" xlink:href=\"#DejaVuSans-73\"/>\r\n     <use x=\"1209.867188\" xlink:href=\"#DejaVuSans-2c\"/>\r\n     <use x=\"1241.654297\" xlink:href=\"#DejaVuSans-20\"/>\r\n     <use x=\"1273.441406\" xlink:href=\"#DejaVuSans-41\"/>\r\n     <use x=\"1340.099609\" xlink:href=\"#DejaVuSans-3a\"/>\r\n     <use x=\"1373.791016\" xlink:href=\"#DejaVuSans-20\"/>\r\n     <use x=\"1405.578125\" xlink:href=\"#DejaVuSans-48\"/>\r\n     <use x=\"1480.773438\" xlink:href=\"#DejaVuSans-61\"/>\r\n     <use x=\"1542.052734\" xlink:href=\"#DejaVuSans-70\"/>\r\n     <use x=\"1605.529297\" xlink:href=\"#DejaVuSans-70\"/>\r\n     <use x=\"1669.005859\" xlink:href=\"#DejaVuSans-69\"/>\r\n     <use x=\"1696.789062\" xlink:href=\"#DejaVuSans-6e\"/>\r\n     <use x=\"1760.167969\" xlink:href=\"#DejaVuSans-65\"/>\r\n     <use x=\"1821.691406\" xlink:href=\"#DejaVuSans-73\"/>\r\n     <use x=\"1873.791016\" xlink:href=\"#DejaVuSans-73\"/>\r\n    </g>\r\n   </g>\r\n  </g>\r\n  <g id=\"text_12\">\r\n   <!-- Sadness : 0.53 Happiness : 0.23  -->\r\n   <g style=\"fill:#ffffff;\" transform=\"translate(31.782188 16.318125)scale(0.12 -0.12)\">\r\n    <use xlink:href=\"#DejaVuSans-53\"/>\r\n    <use x=\"63.476562\" xlink:href=\"#DejaVuSans-61\"/>\r\n    <use x=\"124.755859\" xlink:href=\"#DejaVuSans-64\"/>\r\n    <use x=\"188.232422\" xlink:href=\"#DejaVuSans-6e\"/>\r\n    <use x=\"251.611328\" xlink:href=\"#DejaVuSans-65\"/>\r\n    <use x=\"313.134766\" xlink:href=\"#DejaVuSans-73\"/>\r\n    <use x=\"365.234375\" xlink:href=\"#DejaVuSans-73\"/>\r\n    <use x=\"417.333984\" xlink:href=\"#DejaVuSans-20\"/>\r\n    <use x=\"449.121094\" xlink:href=\"#DejaVuSans-3a\"/>\r\n    <use x=\"482.8125\" xlink:href=\"#DejaVuSans-20\"/>\r\n    <use x=\"514.599609\" xlink:href=\"#DejaVuSans-30\"/>\r\n    <use x=\"578.222656\" xlink:href=\"#DejaVuSans-2e\"/>\r\n    <use x=\"610.009766\" xlink:href=\"#DejaVuSans-35\"/>\r\n    <use x=\"673.632812\" xlink:href=\"#DejaVuSans-33\"/>\r\n    <use x=\"737.255859\" xlink:href=\"#DejaVuSans-20\"/>\r\n    <use x=\"769.042969\" xlink:href=\"#DejaVuSans-48\"/>\r\n    <use x=\"844.238281\" xlink:href=\"#DejaVuSans-61\"/>\r\n    <use x=\"905.517578\" xlink:href=\"#DejaVuSans-70\"/>\r\n    <use x=\"968.994141\" xlink:href=\"#DejaVuSans-70\"/>\r\n    <use x=\"1032.470703\" xlink:href=\"#DejaVuSans-69\"/>\r\n    <use x=\"1060.253906\" xlink:href=\"#DejaVuSans-6e\"/>\r\n    <use x=\"1123.632812\" xlink:href=\"#DejaVuSans-65\"/>\r\n    <use x=\"1185.15625\" xlink:href=\"#DejaVuSans-73\"/>\r\n    <use x=\"1237.255859\" xlink:href=\"#DejaVuSans-73\"/>\r\n    <use x=\"1289.355469\" xlink:href=\"#DejaVuSans-20\"/>\r\n    <use x=\"1321.142578\" xlink:href=\"#DejaVuSans-3a\"/>\r\n    <use x=\"1354.833984\" xlink:href=\"#DejaVuSans-20\"/>\r\n    <use x=\"1386.621094\" xlink:href=\"#DejaVuSans-30\"/>\r\n    <use x=\"1450.244141\" xlink:href=\"#DejaVuSans-2e\"/>\r\n    <use x=\"1482.03125\" xlink:href=\"#DejaVuSans-32\"/>\r\n    <use x=\"1545.654297\" xlink:href=\"#DejaVuSans-33\"/>\r\n    <use x=\"1609.277344\" xlink:href=\"#DejaVuSans-20\"/>\r\n   </g>\r\n  </g>\r\n </g>\r\n <defs>\r\n  <clipPath id=\"p9dd0c0a641\">\r\n   <rect height=\"217.44\" width=\"217.44\" x=\"26.925\" y=\"36\"/>\r\n  </clipPath>\r\n </defs>\r\n</svg>\r\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "data_module.setup(\"test\")\n",
        "\n",
        "evaluate(facial_model, data_module.test_dataloader(), log_path=LOG_PATH, testing=True)\n",
        "'1'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### Make prediction"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {},
      "outputs": [
        {
          "ename": "NameError",
          "evalue": "name 'facial_model' is not defined",
          "output_type": "error",
          "traceback": [
            "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_10940/2255713385.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     32\u001b[0m             \u001b[0mi\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     33\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 34\u001b[1;33m \u001b[0mpredict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfacial_model\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;34m'./dataset/test/subject1.jpeg'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'./dataset/test/subject2.jpeg'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[1;31mNameError\u001b[0m: name 'facial_model' is not defined"
          ]
        }
      ],
      "source": [
        "def predict(model, paths):\n",
        "    row =len(paths)\n",
        "    col = 1\n",
        "    i = 1\n",
        "#     plt.figure(figsize=(25, 20))\n",
        "    \n",
        "    with torch.no_grad():\n",
        "        model.eval()\n",
        "        start_time = time.time()\n",
        "        images = torch.Tensor([transforms.Resize((100, 100))(load_image(x)).numpy() for x in paths]).to(DEVICE)\n",
        "        \n",
        "        outputs = model(images)\n",
        "        end_time = time.time()\n",
        "        \n",
        "        print(\"Time:\", (end_time-start_time) * 1000, \"ms\")\n",
        "        \n",
        "        probabs = nn.functional.softmax(outputs, dim=1)\n",
        "        predicted = torch.argmax(probabs, dim=1).long()\n",
        "        \n",
        "        for ind, pred in enumerate(predicted):\n",
        "            if images[ind].shape[0] == 1:\n",
        "                plt.imshow(images[ind].detach().cpu().numpy().squeeze(), cmap='gray')\n",
        "            else:\n",
        "                plt.imshow(Image.open(paths[ind]))\n",
        "                \n",
        "            plt.axis('off')\n",
        "            plt.title(\"Probab: \" + str(round(probabs[ind][pred].item() * 100) / 100) + \" P: \" + CLASS_LABELS[str(pred.item())])\n",
        "            for index, probab in enumerate(probabs[ind]):\n",
        "                print(CLASS_LABELS[str(index)], \":\", round(probab.item() * 100) / 100)\n",
        "            print()\n",
        "            plt.show()\n",
        "            i += 1\n",
        "            \n",
        "predict(facial_model, ['./dataset/test/subject1.jpeg', './dataset/test/subject2.jpeg'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {},
      "outputs": [],
      "source": [
        "if not exists('./checkpoints/resnet18-ep30.pt'):\n",
        "    torch.save(facial_model.state_dict(), './checkpoints/resnet18-ep30.pt')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {},
      "outputs": [],
      "source": [
        "import cv2\n",
        "import numpy as np\n",
        "\n",
        "face_classifier = cv2.CascadeClassifier('./cv2/haarcascade_frontalface_default.xml')\n",
        "\n",
        "cap = cv2.VideoCapture(0)\n",
        "\n",
        "while True:\n",
        "    facial_model.eval()\n",
        "    _, frame = cap.read()\n",
        "    labels = []\n",
        "    rgb = cv2.cvtColor(frame,cv2.COLOR_BGR2RGB)\n",
        "    faces = face_classifier.detectMultiScale(rgb, scaleFactor=1.2, minNeighbors=5)\n",
        "\n",
        "    for (x,y,w,h) in faces:\n",
        "        cv2.rectangle(frame,(x,y),(x+w,y+h),(0,255,255),2)\n",
        "        roi_rgb = rgb[y:y+h,x:x+w]\n",
        "        roi_rgb = cv2.resize(roi_rgb,(100,100))\n",
        "        # print(roi_rgb.shape)\n",
        "        if np.sum(roi_rgb) != 0:\n",
        "            # roi = torch.Tensor(roi_rgb.reshape(3, 100, 100)).unsqueeze_(dim=0).to(DEVICE)\n",
        "            roi = transforms.ToTensor()(roi_rgb).unsqueeze_(dim=0).to(DEVICE)\n",
        "\n",
        "            prediction = nn.functional.softmax(facial_model(roi), dim=1)[0]\n",
        "            # print(prediction.argmax())\n",
        "            ind = prediction.argmax().item()\n",
        "            label= CLASS_LABELS[str(ind)]\n",
        "            label_position = (x,y)\n",
        "            cv2.putText(frame,label + \" \" + str(round(prediction[ind].item() * 100) / 100),label_position,cv2.FONT_HERSHEY_SIMPLEX,1,(0,255,0),2)\n",
        "        else:\n",
        "            cv2.putText(frame,'No Faces',(30,80),cv2.FONT_HERSHEY_SIMPLEX,1,(0,255,0),2)\n",
        "        \n",
        "    cv2.imshow('Emotion Detector',frame)\n",
        "    if cv2.waitKey(1) & 0xFF == ord('q'):\n",
        "        break\n",
        "\n",
        "cap.release()\n",
        "cv2.destroyAllWindows()\n",
        "\n",
        "# plt.imshow(roi[0].detach().cpu().numpy().transpose(1, 2, 0))\n",
        "# plt.imshow(roi_rgb)"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [],
      "name": "Facial_emotional_detector_v1.ipynb",
      "provenance": []
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3.9.7 ('base')",
      "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.9.7"
    },
    "vscode": {
      "interpreter": {
        "hash": "b2bb06df3a58841ba0c26b5f09bf2e9d1ef6be6ba3138ea8c8abfadc118ea9ba"
      }
    },
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "0842aafc1f9d4cf4bbf20cba117217e0": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_1557bf48e4d249b1a4ecb6431ec5d6c3",
            "placeholder": "​",
            "style": "IPY_MODEL_320d78eb882b4c24a817fcf32f3cf879",
            "value": "Sanity Checking DataLoader 0: 100%"
          }
        },
        "14492847902143c097725bf465fbb815": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "FloatProgressModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_987334a6e9d24d088d10dd1611fddc55",
            "max": 2,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_a8f79e1e5c344ee8831812a388256e40",
            "value": 2
          }
        },
        "1557bf48e4d249b1a4ecb6431ec5d6c3": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "1881f4ef3f1641ae9135df0b6cc3dd20": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "2707b8d3635f4469815e347c561955a9": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "320d78eb882b4c24a817fcf32f3cf879": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "3c2a86250e29410d904202fb8411c6b5": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "448789856cf046e6af46922737d85347": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": "inline-flex",
            "flex": null,
            "flex_flow": "row wrap",
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": "100%"
          }
        },
        "4c9c95a8ee3949eaa55e451bacebe0df": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "FloatProgressModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_53b47c9f4de64404b1422f9a88869e5c",
            "max": 385,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_cd937a4fc493428abbb4accbeb883fd5",
            "value": 0
          }
        },
        "4d70108e3d2248eb9cf863a76c5e713f": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "53b47c9f4de64404b1422f9a88869e5c": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": "2",
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "76a29a2444f24315864aeda040b653fe": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HBoxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_0842aafc1f9d4cf4bbf20cba117217e0",
              "IPY_MODEL_14492847902143c097725bf465fbb815",
              "IPY_MODEL_7ef89c79720f4631988e416021092ca1"
            ],
            "layout": "IPY_MODEL_448789856cf046e6af46922737d85347"
          }
        },
        "7d4af37e834b4ebb968e23d4147ad117": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "7ef89c79720f4631988e416021092ca1": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_1881f4ef3f1641ae9135df0b6cc3dd20",
            "placeholder": "​",
            "style": "IPY_MODEL_fa31d6529bd54739a1cc1584853227f2",
            "value": " 2/2 [00:26&lt;00:00, 13.19s/it]"
          }
        },
        "922f0488b3ff4c16a76319cdd9ef9bc0": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HBoxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_e189a18b60434a7c90b9c411dcc3fb48",
              "IPY_MODEL_4c9c95a8ee3949eaa55e451bacebe0df",
              "IPY_MODEL_d26a93f1f286432baedce846789aad66"
            ],
            "layout": "IPY_MODEL_a8e7551243d14e9ba6a4553ac7bd98a6"
          }
        },
        "987334a6e9d24d088d10dd1611fddc55": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": "2",
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "a8e7551243d14e9ba6a4553ac7bd98a6": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": "inline-flex",
            "flex": null,
            "flex_flow": "row wrap",
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": "100%"
          }
        },
        "a8f79e1e5c344ee8831812a388256e40": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ProgressStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "cd937a4fc493428abbb4accbeb883fd5": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ProgressStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "d26a93f1f286432baedce846789aad66": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_2707b8d3635f4469815e347c561955a9",
            "placeholder": "​",
            "style": "IPY_MODEL_7d4af37e834b4ebb968e23d4147ad117",
            "value": " 0/385 [00:00&lt;?, ?it/s]"
          }
        },
        "e189a18b60434a7c90b9c411dcc3fb48": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_4d70108e3d2248eb9cf863a76c5e713f",
            "placeholder": "​",
            "style": "IPY_MODEL_3c2a86250e29410d904202fb8411c6b5",
            "value": "Epoch 0:   0%"
          }
        },
        "fa31d6529bd54739a1cc1584853227f2": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        }
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}