From fb76f6f37c9db7d462fb95cccee57c286b4ec96f Mon Sep 17 00:00:00 2001
From: Mario Sessa <76259752+kode-git@users.noreply.github.com>
Date: Fri, 13 May 2022 21:51:42 +0200
Subject: [PATCH] Adding evaluation for ResNet18

---
 ViT_Face_Emotion_Recognition.ipynb | 1107 ++++++++++++++++++++++++----
 1 file changed, 961 insertions(+), 146 deletions(-)

diff --git a/ViT_Face_Emotion_Recognition.ipynb b/ViT_Face_Emotion_Recognition.ipynb
index 40cf457..f3f5b42 100644
--- a/ViT_Face_Emotion_Recognition.ipynb
+++ b/ViT_Face_Emotion_Recognition.ipynb
@@ -66,13 +66,13 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 1,
+      "execution_count": 14,
       "metadata": {
         "id": "TBLS3rKGcIUm",
         "colab": {
           "base_uri": "https://localhost:8080/"
         },
-        "outputId": "babab063-07b2-4b5b-8c88-c15ecbf48680"
+        "outputId": "52a24af5-1474-4e73-92a9-89b97fd2df19"
       },
       "outputs": [
         {
@@ -85,21 +85,17 @@
             "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas) (2022.1)\n",
             "Requirement already satisfied: numpy>=1.17.3 in /usr/local/lib/python3.7/dist-packages (from pandas) (1.21.6)\n",
             "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.7.3->pandas) (1.15.0)\n",
-            "Collecting timm\n",
-            "  Downloading timm-0.5.4-py3-none-any.whl (431 kB)\n",
-            "\u001b[K     |████████████████████████████████| 431 kB 5.2 MB/s \n",
-            "\u001b[?25hRequirement already satisfied: torchvision in /usr/local/lib/python3.7/dist-packages (from timm) (0.12.0+cu113)\n",
+            "Requirement already satisfied: timm in /usr/local/lib/python3.7/dist-packages (0.5.4)\n",
+            "Requirement already satisfied: torchvision in /usr/local/lib/python3.7/dist-packages (from timm) (0.12.0+cu113)\n",
             "Requirement already satisfied: torch>=1.4 in /usr/local/lib/python3.7/dist-packages (from timm) (1.11.0+cu113)\n",
             "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from torch>=1.4->timm) (4.2.0)\n",
-            "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /usr/local/lib/python3.7/dist-packages (from torchvision->timm) (7.1.2)\n",
-            "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from torchvision->timm) (1.21.6)\n",
             "Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from torchvision->timm) (2.23.0)\n",
-            "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests->torchvision->timm) (1.24.3)\n",
-            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->torchvision->timm) (2.10)\n",
+            "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from torchvision->timm) (1.21.6)\n",
+            "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /usr/local/lib/python3.7/dist-packages (from torchvision->timm) (7.1.2)\n",
             "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->torchvision->timm) (3.0.4)\n",
             "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests->torchvision->timm) (2021.10.8)\n",
-            "Installing collected packages: timm\n",
-            "Successfully installed timm-0.5.4\n"
+            "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests->torchvision->timm) (1.24.3)\n",
+            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->torchvision->timm) (2.10)\n"
           ]
         }
       ],
@@ -119,28 +115,22 @@
         "colab": {
           "base_uri": "https://localhost:8080/"
         },
-        "outputId": "6eb111d7-35f9-4709-df62-5b607b1f86b3"
+        "outputId": "b648584f-44a4-4cee-80b2-a012c0fb244e"
       },
-      "execution_count": 2,
+      "execution_count": 15,
       "outputs": [
         {
           "output_type": "stream",
           "name": "stdout",
           "text": [
-            "Cloning into 'sam'...\n",
-            "remote: Enumerating objects: 179, done.\u001b[K\n",
-            "remote: Counting objects: 100% (75/75), done.\u001b[K\n",
-            "remote: Compressing objects: 100% (22/22), done.\u001b[K\n",
-            "remote: Total 179 (delta 62), reused 53 (delta 53), pack-reused 104\u001b[K\n",
-            "Receiving objects: 100% (179/179), 650.16 KiB | 11.82 MiB/s, done.\n",
-            "Resolving deltas: 100% (84/84), done.\n"
+            "fatal: destination path 'sam' already exists and is not an empty directory.\n"
           ]
         }
       ]
     },
     {
       "cell_type": "code",
-      "execution_count": 3,
+      "execution_count": 33,
       "metadata": {
         "id": "66hzxAClAFAY"
       },
@@ -167,6 +157,7 @@
         "\n",
         "# machine learning libraries \n",
         "import timm, torch, torchvision\n",
+        "from torchsummary import summary\n",
         "\n",
         "# image dataset loading and transformations\n",
         "from torchvision import datasets, models, transforms\n",
@@ -211,20 +202,19 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 4,
+      "execution_count": 17,
       "metadata": {
         "id": "0WafVw77sp2v",
         "colab": {
           "base_uri": "https://localhost:8080/"
         },
-        "outputId": "9267c4ae-f520-4148-bdf9-955ab05c1be6"
+        "outputId": "19189625-9196-4229-eab8-9a87dd38bba2"
       },
       "outputs": [
         {
           "output_type": "stream",
           "name": "stdout",
           "text": [
-            "Drive not mounted, so nothing to flush and unmount.\n",
             "Mounted at /content/drive\n"
           ]
         }
@@ -262,7 +252,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 5,
       "metadata": {
         "id": "mMiGrpYXLFNP"
       },
@@ -349,7 +339,7 @@
     {
       "cell_type": "markdown",
       "source": [
-        "#### 2.4 Other useful functions"
+        "### 2.4 Other useful functions"
       ],
       "metadata": {
         "id": "of7icy3oMwUt"
@@ -369,7 +359,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 6,
       "metadata": {
         "id": "NfjxfLlujLZi"
       },
@@ -3905,7 +3895,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 5,
+      "execution_count": 18,
       "metadata": {
         "id": "rZYiTth-y7yy"
       },
@@ -3919,7 +3909,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 6,
+      "execution_count": 19,
       "metadata": {
         "id": "yk-iKrzguAQR"
       },
@@ -3932,31 +3922,11 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 8,
+      "execution_count": null,
       "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "MW0qScRotgal",
-        "outputId": "f8aa2f20-3c97-4cdf-c590-08400adcc85e"
+        "id": "MW0qScRotgal"
       },
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Initializing Datasets and Dataloaders...\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py:490: UserWarning: This DataLoader will create 8 worker processes in total. Our suggested max number of worker in current system is 4, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n",
-            "  cpuset_checked))\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
         "data_transforms = {\n",
         "    'train': transforms.Compose([\n",
@@ -3986,7 +3956,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 9,
+      "execution_count": null,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/"
@@ -4011,7 +3981,48 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 10,
+      "source": [
+        "!nvidia-smi"
+      ],
+      "metadata": {
+        "id": "Sth7pXGVUJDs",
+        "outputId": "3e769f93-1659-472c-9c7c-37b52cce5030",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": 32,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Fri May 13 16:46:34 2022       \n",
+            "+-----------------------------------------------------------------------------+\n",
+            "| NVIDIA-SMI 460.32.03    Driver Version: 460.32.03    CUDA Version: 11.2     |\n",
+            "|-------------------------------+----------------------+----------------------+\n",
+            "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
+            "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
+            "|                               |                      |               MIG M. |\n",
+            "|===============================+======================+======================|\n",
+            "|   0  Tesla T4            Off  | 00000000:00:04.0 Off |                    0 |\n",
+            "| N/A   67C    P0    31W /  70W |   1442MiB / 15109MiB |      0%      Default |\n",
+            "|                               |                      |                  N/A |\n",
+            "+-------------------------------+----------------------+----------------------+\n",
+            "                                                                               \n",
+            "+-----------------------------------------------------------------------------+\n",
+            "| Processes:                                                                  |\n",
+            "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
+            "|        ID   ID                                                   Usage      |\n",
+            "|=============================================================================|\n",
+            "+-----------------------------------------------------------------------------+\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
       "metadata": {
         "id": "OY4wmSSvyR2r"
       },
@@ -4023,7 +4034,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 11,
+      "execution_count": null,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/"
@@ -4276,7 +4287,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 12,
+      "execution_count": null,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/"
@@ -4530,7 +4541,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 13,
+      "execution_count": 11,
       "metadata": {
         "id": "MfPgq1CyyuRW"
       },
@@ -4684,12 +4695,12 @@
       "metadata": {
         "id": "DmRq96ZqLHhy"
       },
-      "execution_count": 14,
+      "execution_count": null,
       "outputs": []
     },
     {
       "cell_type": "code",
-      "execution_count": 15,
+      "execution_count": null,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/"
@@ -4901,7 +4912,7 @@
         "id": "TxoRhdLgLgjd",
         "outputId": "83ab9c94-ea35-42b1-c044-111fbb207987"
       },
-      "execution_count": 16,
+      "execution_count": null,
       "outputs": [
         {
           "output_type": "execute_result",
@@ -4937,7 +4948,7 @@
       "metadata": {
         "id": "s2CyAO1JdOxJ"
       },
-      "execution_count": 17,
+      "execution_count": null,
       "outputs": []
     },
     {
@@ -4952,7 +4963,7 @@
       "metadata": {
         "id": "WA3BGlRPdV_7"
       },
-      "execution_count": 18,
+      "execution_count": null,
       "outputs": []
     },
     {
@@ -5227,7 +5238,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 205,
       "metadata": {
         "id": "7cHhjlB665Yq"
       },
@@ -5235,20 +5246,28 @@
       "source": [
         "# plot and data management functions\n",
         "\n",
-        "def plot_graphs(train, val, num_epochs, limity = None, labelr = \"\", labelb =\"\", xlabel=\"Epochs\", ylabel=\"%\", title=\"Plot\", stepx_size = 1):\n",
-        "    ran = list(range(1, num_epochs + 1, stepx_size))\n",
-        "    print(ran)\n",
-        "    plt.figure(figsize=(16,5))\n",
-        "    plt.subplot(1, 2, 1)\n",
-        "    plt.xlim(1, num_epochs)\n",
-        "    plt.ylim(0, limity)\n",
-        "    plt.plot(ran, train, marker='o', linestyle='--', color='r',  label=labelr) \n",
-        "    plt.plot(ran, val, marker='o', linestyle='--', color='b',  label=labelb) \n",
-        "    plt.xlabel(xlabel)\n",
-        "    plt.ylabel(ylabel) \n",
-        "    plt.title(title)\n",
-        "    plt.legend() \n",
-        "    plt.show()\n",
+        "def multi_plot(curves, num_epochs, labels = [], xlabel=\"Epochs\", ylabel=\"\", title=\"Plot\", stepx_size = 1, vert_size = None):\n",
+        "  ran = list(range(1, num_epochs + 1, stepx_size)) # 1 to num_epochs on x axes\n",
+        "  plt.figure(figsize=(16,5))\n",
+        "  plt.subplot(1,len(curves), 1)\n",
+        "  plt.xlim(1, num_epochs)\n",
+        "  plt.ylim(0, vert_size)\n",
+        "  if len(curves) != len(labels):\n",
+        "    raise IndexError('Curves size don\\'t match with labels: {} -> {}'.format(len(curves), len(labels)))\n",
+        "  if not len(curves) or len(curves) > 4:\n",
+        "    raise IndexError('Curves collection oversize or downsize, support plot until 4 lines but curves has size of {}'.format(len(curves)))\n",
+        "  colors = ['b', 'g', 'r', 'c']\n",
+        "  for i in range(len(curves)):\n",
+        "    plt.plot(ran, curves[i], marker='o', linestyle='--', color=colors[i], label=labels[i])\n",
+        "\n",
+        "  # metadata\n",
+        "  plt.xlabel(xlabel)\n",
+        "  plt.ylabel(ylabel)\n",
+        "  plt.title(title)\n",
+        "  plt.legend()\n",
+        "\n",
+        "  # plot showing\n",
+        "  plt.show()\n",
         "\n",
         "\n",
         "def tensor_to_list(tensor_list):\n",
@@ -5303,7 +5322,7 @@
       "metadata": {
         "id": "hwLVUh2VR7NN"
       },
-      "execution_count": null,
+      "execution_count": 13,
       "outputs": []
     },
     {
@@ -5315,6 +5334,404 @@
         "id": "ebScBIGXcHu4"
       }
     },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "#### 7.1.1 Training Evaluation"
+      ],
+      "metadata": {
+        "id": "ML7m4rTzhHym"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# load history divided by steps\n",
+        "steps = [25]\n",
+        "base_dir = \"/content/drive/MyDrive/Models/\"\n",
+        "train_accuracy = []\n",
+        "val_accuracy = []\n",
+        "train_loss = []\n",
+        "val_loss = []\n",
+        "for step in steps:\n",
+        "  name_model = \"resnet18_\" + str(step)\n",
+        "  model_folder = base_dir + name_model + \"/\"\n",
+        "  train_accuracy += tensor_to_list(load_history(model_folder + name_model + \"_history_train\"))\n",
+        "  val_accuracy += tensor_to_list(load_history(model_folder + name_model + \"_history_val\"))\n",
+        "  step_loss = load_history(base_dir + name_model + \"/\" + name_model + \"_history_loss\")\n",
+        "  train_loss += step_loss['train']\n",
+        "  val_loss += step_loss['val']"
+      ],
+      "metadata": {
+        "id": "QCtJVMp1SF8n"
+      },
+      "execution_count": 153,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# we need to merge them together\n",
+        "for i in range(len(train_accuracy)):\n",
+        "  train_accuracy[i] = round(train_accuracy[i], 6)\n",
+        "  val_accuracy[i] = round(val_accuracy[i], 6)\n",
+        "  val_loss[i] = round(val_loss[i], 6)\n",
+        "  train_loss[i] = round(train_loss[i], 6)"
+      ],
+      "metadata": {
+        "id": "q7-6MlFkSV20"
+      },
+      "execution_count": 154,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "multi_plot([train_accuracy, val_accuracy], 25, labels=['Training Accuracy', 'Validation Accuracy'], title=\"ResNet18 Accuracy Plot\", ylabel=\"% Accuracy\" )"
+      ],
+      "metadata": {
+        "id": "SwsM-fS1w-VC",
+        "outputId": "b849c506-b6f3-4d52-fdb6-6bfc12c919c4",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 350
+        }
+      },
+      "execution_count": 155,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1152x360 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "multi_plot([train_loss, val_loss], 25, labels=['Training Loss', 'Validation Loss'], title=\"ResNet18 Loss Plot\", ylabel=\"% Loss\", vert_size=2.5 )"
+      ],
+      "metadata": {
+        "id": "2o15U5OuSgbV",
+        "outputId": "28dfc2a6-b05a-4622-b89b-d44267b6a1f8",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 350
+        }
+      },
+      "execution_count": 159,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1152x360 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "#### 7.1.2 Testing on AffectNet"
+      ],
+      "metadata": {
+        "id": "r3BFDk36hTKo"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "data_dir= \"/content/drive/MyDrive/Datasets/VFER/\"\n",
+        "data_transforms_test = {\n",
+        "    'test': transforms.Compose([\n",
+        "        transforms.Resize(input_size),\n",
+        "        transforms.ToTensor(),\n",
+        "        transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])\n",
+        "    ]),\n",
+        "}\n",
+        "\n",
+        "# Create training and validation datasets\n",
+        "image_datasets_test = {x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms_test[x]) for x in ['test']}\n",
+        "\n",
+        "# Create training and validation dataloaders\n",
+        "dataloaders_dict_test = {x: torch.utils.data.DataLoader(image_datasets_test[x], batch_size=batch_size, shuffle=False, num_workers=2,pin_memory=True) for x in [ 'test']}\n"
+      ],
+      "metadata": {
+        "id": "xCGPhbPhTEDP"
+      },
+      "execution_count": 140,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# setting the path of the model to be imported\n",
+        "model_path='/content/drive/MyDrive/Models/resnet18_25/resnet18_25.pth'\n",
+        "model = timm.create_model('resnet18', pretrained=True)\n",
+        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+        "model.to(device)\n",
+        "summary(model,input_size=(3, 224, 224))\n",
+        "model.fc = nn.Linear(512, 8)\n",
+        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+        "print(device)\n",
+        "# Send the model to GPU\n",
+        "model = model.to(device)\n",
+        "scores,labels = test_model(model, dataloaders_dict_test, True, load_state_ws=model_path)"
+      ],
+      "metadata": {
+        "id": "Slr87KNlTFDv",
+        "outputId": "ca652d0a-72d4-4958-8677-bca33e38efb0",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": 141,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "----------------------------------------------------------------\n",
+            "        Layer (type)               Output Shape         Param #\n",
+            "================================================================\n",
+            "            Conv2d-1         [-1, 64, 112, 112]           9,408\n",
+            "       BatchNorm2d-2         [-1, 64, 112, 112]             128\n",
+            "              ReLU-3         [-1, 64, 112, 112]               0\n",
+            "         MaxPool2d-4           [-1, 64, 56, 56]               0\n",
+            "            Conv2d-5           [-1, 64, 56, 56]          36,864\n",
+            "       BatchNorm2d-6           [-1, 64, 56, 56]             128\n",
+            "              ReLU-7           [-1, 64, 56, 56]               0\n",
+            "            Conv2d-8           [-1, 64, 56, 56]          36,864\n",
+            "       BatchNorm2d-9           [-1, 64, 56, 56]             128\n",
+            "             ReLU-10           [-1, 64, 56, 56]               0\n",
+            "       BasicBlock-11           [-1, 64, 56, 56]               0\n",
+            "           Conv2d-12           [-1, 64, 56, 56]          36,864\n",
+            "      BatchNorm2d-13           [-1, 64, 56, 56]             128\n",
+            "             ReLU-14           [-1, 64, 56, 56]               0\n",
+            "           Conv2d-15           [-1, 64, 56, 56]          36,864\n",
+            "      BatchNorm2d-16           [-1, 64, 56, 56]             128\n",
+            "             ReLU-17           [-1, 64, 56, 56]               0\n",
+            "       BasicBlock-18           [-1, 64, 56, 56]               0\n",
+            "           Conv2d-19          [-1, 128, 28, 28]          73,728\n",
+            "      BatchNorm2d-20          [-1, 128, 28, 28]             256\n",
+            "             ReLU-21          [-1, 128, 28, 28]               0\n",
+            "           Conv2d-22          [-1, 128, 28, 28]         147,456\n",
+            "      BatchNorm2d-23          [-1, 128, 28, 28]             256\n",
+            "           Conv2d-24          [-1, 128, 28, 28]           8,192\n",
+            "      BatchNorm2d-25          [-1, 128, 28, 28]             256\n",
+            "             ReLU-26          [-1, 128, 28, 28]               0\n",
+            "       BasicBlock-27          [-1, 128, 28, 28]               0\n",
+            "           Conv2d-28          [-1, 128, 28, 28]         147,456\n",
+            "      BatchNorm2d-29          [-1, 128, 28, 28]             256\n",
+            "             ReLU-30          [-1, 128, 28, 28]               0\n",
+            "           Conv2d-31          [-1, 128, 28, 28]         147,456\n",
+            "      BatchNorm2d-32          [-1, 128, 28, 28]             256\n",
+            "             ReLU-33          [-1, 128, 28, 28]               0\n",
+            "       BasicBlock-34          [-1, 128, 28, 28]               0\n",
+            "           Conv2d-35          [-1, 256, 14, 14]         294,912\n",
+            "      BatchNorm2d-36          [-1, 256, 14, 14]             512\n",
+            "             ReLU-37          [-1, 256, 14, 14]               0\n",
+            "           Conv2d-38          [-1, 256, 14, 14]         589,824\n",
+            "      BatchNorm2d-39          [-1, 256, 14, 14]             512\n",
+            "           Conv2d-40          [-1, 256, 14, 14]          32,768\n",
+            "      BatchNorm2d-41          [-1, 256, 14, 14]             512\n",
+            "             ReLU-42          [-1, 256, 14, 14]               0\n",
+            "       BasicBlock-43          [-1, 256, 14, 14]               0\n",
+            "           Conv2d-44          [-1, 256, 14, 14]         589,824\n",
+            "      BatchNorm2d-45          [-1, 256, 14, 14]             512\n",
+            "             ReLU-46          [-1, 256, 14, 14]               0\n",
+            "           Conv2d-47          [-1, 256, 14, 14]         589,824\n",
+            "      BatchNorm2d-48          [-1, 256, 14, 14]             512\n",
+            "             ReLU-49          [-1, 256, 14, 14]               0\n",
+            "       BasicBlock-50          [-1, 256, 14, 14]               0\n",
+            "           Conv2d-51            [-1, 512, 7, 7]       1,179,648\n",
+            "      BatchNorm2d-52            [-1, 512, 7, 7]           1,024\n",
+            "             ReLU-53            [-1, 512, 7, 7]               0\n",
+            "           Conv2d-54            [-1, 512, 7, 7]       2,359,296\n",
+            "      BatchNorm2d-55            [-1, 512, 7, 7]           1,024\n",
+            "           Conv2d-56            [-1, 512, 7, 7]         131,072\n",
+            "      BatchNorm2d-57            [-1, 512, 7, 7]           1,024\n",
+            "             ReLU-58            [-1, 512, 7, 7]               0\n",
+            "       BasicBlock-59            [-1, 512, 7, 7]               0\n",
+            "           Conv2d-60            [-1, 512, 7, 7]       2,359,296\n",
+            "      BatchNorm2d-61            [-1, 512, 7, 7]           1,024\n",
+            "             ReLU-62            [-1, 512, 7, 7]               0\n",
+            "           Conv2d-63            [-1, 512, 7, 7]       2,359,296\n",
+            "      BatchNorm2d-64            [-1, 512, 7, 7]           1,024\n",
+            "             ReLU-65            [-1, 512, 7, 7]               0\n",
+            "       BasicBlock-66            [-1, 512, 7, 7]               0\n",
+            "AdaptiveAvgPool2d-67            [-1, 512, 1, 1]               0\n",
+            "          Flatten-68                  [-1, 512]               0\n",
+            "SelectAdaptivePool2d-69                  [-1, 512]               0\n",
+            "           Linear-70                 [-1, 1000]         513,000\n",
+            "================================================================\n",
+            "Total params: 11,689,512\n",
+            "Trainable params: 11,689,512\n",
+            "Non-trainable params: 0\n",
+            "----------------------------------------------------------------\n",
+            "Input size (MB): 0.57\n",
+            "Forward/backward pass size (MB): 62.80\n",
+            "Params size (MB): 44.59\n",
+            "Estimated Total Size (MB): 107.97\n",
+            "----------------------------------------------------------------\n",
+            "cuda:0\n",
+            "Model loaded correctly\n",
+            "Testing phase start...\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "y_true = labels\n",
+        "y_pred= np.argmax(scores,1)\n",
+        "categories = [\"anger\", \"contempt\", \"disgust\", \"fear\", \"happy\", \"neutral\", \"sadness\", \"surprise\"]\n",
+        "\n",
+        "\n",
+        "#labels = train_ds.features['label'].names\n",
+        "cm = confusion_matrix(y_true, y_pred)\n",
+        "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=categories)\n",
+        "disp.plot(xticks_rotation=45)"
+      ],
+      "metadata": {
+        "id": "OQACTpmsXIRF",
+        "outputId": "cf518959-3763-4f13-ba86-d4e837d5b39d",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 327
+        }
+      },
+      "execution_count": 142,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<sklearn.metrics._plot.confusion_matrix.ConfusionMatrixDisplay at 0x7f39c501a5d0>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 142
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 432x288 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "test_accuracy_8 = accuracy_score(y_true, y_pred, normalize=True)\n",
+        "print('Test Accuracy on AffectNet with 8-classes: {}'.format(round(test_accuracy_8,4)))"
+      ],
+      "metadata": {
+        "id": "18SOCei8hrTy",
+        "outputId": "f0ff00db-917a-4ee9-b3f9-dc2cc0495ae9",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": 143,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Test Accuracy on AffectNet with 8-classes: 0.5005\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "y_true_7 = []\n",
+        "y_pred_7 = []\n",
+        "for i in range(len(y_true)):\n",
+        "  if y_true[i] != 1:\n",
+        "    y_true_7.append(y_true[i])\n",
+        "    y_pred_7.append(y_pred[i])\n",
+        "test_accuracy_7 = accuracy_score(y_true_7, y_pred_7, normalize=True)\n",
+        "print('Test Accuracy on AffectNet with 7-classes: {}'.format(round(test_accuracy_7,4)))"
+      ],
+      "metadata": {
+        "id": "j0CS0YErht2j",
+        "outputId": "9c703cae-fbd6-431d-bd6c-9814b6e1f5b2",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": 144,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Test Accuracy on AffectNet with 7-classes: 0.5277\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "print(metrics.classification_report(y_true, y_pred, digits=4, target_names=categories))"
+      ],
+      "metadata": {
+        "id": "OThwc6rbkfE_",
+        "outputId": "bfe12bf3-c42b-4284-bc87-aaed70b689fe",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": 145,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "              precision    recall  f1-score   support\n",
+            "\n",
+            "       anger     0.4426    0.4780    0.4596       500\n",
+            "    contempt     0.5272    0.3100    0.3904       500\n",
+            "     disgust     0.5833    0.3360    0.4264       500\n",
+            "        fear     0.5846    0.5320    0.5571       500\n",
+            "       happy     0.5978    0.7460    0.6637       500\n",
+            "     neutral     0.3773    0.4520    0.4113       500\n",
+            "     sadness     0.4685    0.5800    0.5183       500\n",
+            "    surprise     0.4905    0.5700    0.5273       500\n",
+            "\n",
+            "    accuracy                         0.5005      4000\n",
+            "   macro avg     0.5090    0.5005    0.4943      4000\n",
+            "weighted avg     0.5090    0.5005    0.4943      4000\n",
+            "\n"
+          ]
+        }
+      ]
+    },
     {
       "cell_type": "markdown",
       "source": [
@@ -5324,6 +5741,15 @@
         "id": "YPVSpJFQb-n_"
       }
     },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "#### 7.2.1 Testing on AffectNet"
+      ],
+      "metadata": {
+        "id": "-3v-q1YwXLvc"
+      }
+    },
     {
       "cell_type": "code",
       "source": [
@@ -5377,6 +5803,116 @@
       "execution_count": null,
       "outputs": []
     },
+    {
+      "cell_type": "code",
+      "source": [
+        "y_true = labels\n",
+        "y_pred= np.argmax(scores,1)\n",
+        "categories = [\"anger\", \"contempt\", \"disgust\", \"fear\", \"happy\", \"neutral\", \"sadness\", \"surprise\"]\n",
+        "\n",
+        "\n",
+        "#labels = train_ds.features['label'].names\n",
+        "cm = confusion_matrix(y_true, y_pred)\n",
+        "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=categories)\n",
+        "disp.plot(xticks_rotation=45)"
+      ],
+      "metadata": {
+        "id": "S-52UsNShpIS"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "test_accuracy_8 = accuracy_score(y_true, y_pred, normalize=True)\n",
+        "print('Test Accuracy on AffectNet with 8-classes: {}'.format(round(test_accuracy_8,4)))"
+      ],
+      "metadata": {
+        "id": "1MEssAtsXRUr",
+        "outputId": "240f5c16-7c46-4417-8676-30d7a54861fe",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": 71,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Test Accuracy on AffectNet with 8-classes: 0.5005\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "y_true_7 = []\n",
+        "y_pred_7 = []\n",
+        "for i in range(len(y_true)):\n",
+        "  if y_true[i] != 1:\n",
+        "    y_true_7.append(y_true[i])\n",
+        "    y_pred_7.append(y_pred[i])\n",
+        "test_accuracy_7 = accuracy_score(y_true_7, y_pred_7, normalize=True)\n",
+        "print('Test Accuracy on AffectNet with 7-classes: {}'.format(round(test_accuracy_7,4)))"
+      ],
+      "metadata": {
+        "id": "f6MpiGVaZBFB",
+        "outputId": "f4f20d1e-ea25-459c-d622-1ab9064d9a47",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": 82,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Test Accuracy on AffectNet with 7-classes: 0.5277\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "print(metrics.classification_report(y_true, y_pred, digits=4, target_names=categories))"
+      ],
+      "metadata": {
+        "id": "CZH66OyuXWhD",
+        "outputId": "5f3dc2a2-fd9c-49a6-f747-a736d5082788",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": 75,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "              precision    recall  f1-score   support\n",
+            "\n",
+            "       anger     0.4426    0.4780    0.4596       500\n",
+            "    contempt     0.5272    0.3100    0.3904       500\n",
+            "     disgust     0.5833    0.3360    0.4264       500\n",
+            "        fear     0.5846    0.5320    0.5571       500\n",
+            "       happy     0.5978    0.7460    0.6637       500\n",
+            "     neutral     0.3773    0.4520    0.4113       500\n",
+            "     sadness     0.4685    0.5800    0.5183       500\n",
+            "    surprise     0.4905    0.5700    0.5273       500\n",
+            "\n",
+            "    accuracy                         0.5005      4000\n",
+            "   macro avg     0.5090    0.5005    0.4943      4000\n",
+            "weighted avg     0.5090    0.5005    0.4943      4000\n",
+            "\n"
+          ]
+        }
+      ]
+    },
     {
       "cell_type": "markdown",
       "source": [
@@ -5404,11 +5940,20 @@
         "id": "McUO4PgxRqIu"
       }
     },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "#### 7.4.1 Training Evaluation"
+      ],
+      "metadata": {
+        "id": "Qxm3u42i6Lcz"
+      }
+    },
     {
       "cell_type": "code",
       "source": [
         "# load history divided by steps\n",
-        "steps = [5, 10, 15, 25]\n",
+        "steps = [25]\n",
         "base_dir = \"/content/drive/MyDrive/Models/\"\n",
         "train_accuracy = []\n",
         "val_accuracy = []\n",
@@ -5426,7 +5971,7 @@
       "metadata": {
         "id": "Q8m_WwwjRmGm"
       },
-      "execution_count": null,
+      "execution_count": 201,
       "outputs": []
     },
     {
@@ -5442,39 +5987,32 @@
       "metadata": {
         "id": "Fc3SEJdNRtDL"
       },
-      "execution_count": null,
+      "execution_count": 202,
       "outputs": []
     },
     {
       "cell_type": "code",
       "source": [
         "# accuracy plot\n",
-        "plot_graphs(train_accuracy, val_accuracy, 25, labelb=\"Validation Accuracy\", labelr=\"Training Accuracy\", ylabel=\"% Accuracy\", title=\"Accuracy Plot\" )"
+        "multi_plot([train_accuracy, val_accuracy], 25, labels=['Training Accuracy', 'Validation Accuracy'], title=\"ResNet18 Accuracy Plot\", ylabel=\"% Accuracy\")"
       ],
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/",
-          "height": 367
+          "height": 350
         },
         "id": "IT7XOelQRuyO",
-        "outputId": "6c998639-aa23-4b79-9c36-b286fcd6f3ec"
+        "outputId": "10147bc7-95e8-43f7-bb35-7d3554dd3f1f"
       },
-      "execution_count": null,
+      "execution_count": 203,
       "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]\n"
-          ]
-        },
         {
           "output_type": "display_data",
           "data": {
             "text/plain": [
               "<Figure size 1152x360 with 1 Axes>"
             ],
-            "image/png": "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\n"
+            "image/png": "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\n"
           },
           "metadata": {
             "needs_background": "light"
@@ -5485,32 +6023,25 @@
     {
       "cell_type": "code",
       "source": [
-        "plot_graphs(train_loss, val_loss, 25, limity= 1.5, labelr=\"Training Loss\", labelb=\"Validation Loss\", title=\"Loss Plot\", ylabel=\"% Loss\")"
+        "multi_plot([train_loss, val_loss], 25, labels=['Training Loss', 'Validation Loss'], title=\"ResNet18 Loss Plot\", ylabel=\"% Loss\", vert_size=2.5 )"
       ],
       "metadata": {
         "id": "dcfEqib6NRH4",
-        "outputId": "19b2c143-973e-4160-9503-f85a048517f0",
+        "outputId": "43030558-f5c8-4bb0-d410-3067d1821afc",
         "colab": {
           "base_uri": "https://localhost:8080/",
-          "height": 367
+          "height": 350
         }
       },
-      "execution_count": null,
+      "execution_count": 204,
       "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]\n"
-          ]
-        },
         {
           "output_type": "display_data",
           "data": {
             "text/plain": [
               "<Figure size 1152x360 with 1 Axes>"
             ],
-            "image/png": "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\n"
+            "image/png": "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\n"
           },
           "metadata": {
             "needs_background": "light"
@@ -5518,9 +6049,19 @@
         }
       ]
     },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "#### 7.4.2 Testing on AffectNet"
+      ],
+      "metadata": {
+        "id": "SyQWAPvq6W8i"
+      }
+    },
     {
       "cell_type": "code",
       "source": [
+        "data_dir= \"/content/drive/MyDrive/Datasets/VFER/\"\n",
         "data_transforms_test = {\n",
         "    'test': transforms.Compose([\n",
         "        transforms.Resize(input_size),\n",
@@ -5538,15 +6079,20 @@
       "metadata": {
         "id": "nuT-gUlVRy4w"
       },
-      "execution_count": null,
+      "execution_count": 206,
       "outputs": []
     },
     {
       "cell_type": "code",
       "source": [
         "#setting the path of the model to be imported\n",
-        "model_path='/content/drive/MyDrive/Models/vfer_sam_10/vfer_sam_10.pth'\n",
+        "model_path='/content/drive/MyDrive/Models/vfer_sam_25/vfer_sam_25.pth'\n",
         "\n",
+        "model = timm.create_model('vit_base_patch16_224', pretrained=True)\n",
+        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+        "model.to(device)\n",
+        "summary(model,input_size=(3, 224, 224))\n",
+        "model.head = nn.Linear(768, 8)\n",
         "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
         "print(device)\n",
         "# Send the model to GPU\n",
@@ -5555,30 +6101,232 @@
       ],
       "metadata": {
         "id": "M5ZhzgHAR8-e",
-        "outputId": "47d84bbb-f18f-42bc-831c-362d77c287b3",
+        "outputId": "bdfff864-9732-403e-a394-c3ca9c2e9556",
         "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 232
+          "base_uri": "https://localhost:8080/"
         }
       },
-      "execution_count": null,
+      "execution_count": 217,
       "outputs": [
         {
           "output_type": "stream",
           "name": "stdout",
           "text": [
-            "cuda:0\n"
-          ]
-        },
-        {
-          "output_type": "error",
-          "ename": "NameError",
-          "evalue": "ignored",
-          "traceback": [
-            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
-            "\u001b[0;32m<ipython-input-16-691643342c76>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;31m# Send the model to GPU\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mmodel\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0mscores\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlabels\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtest_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdataloaders_dict_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mload_state_ws\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmodel_path\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;31mNameError\u001b[0m: name 'model' is not defined"
+            "----------------------------------------------------------------\n",
+            "        Layer (type)               Output Shape         Param #\n",
+            "================================================================\n",
+            "            Conv2d-1          [-1, 768, 14, 14]         590,592\n",
+            "          Identity-2             [-1, 196, 768]               0\n",
+            "        PatchEmbed-3             [-1, 196, 768]               0\n",
+            "           Dropout-4             [-1, 197, 768]               0\n",
+            "         LayerNorm-5             [-1, 197, 768]           1,536\n",
+            "            Linear-6            [-1, 197, 2304]       1,771,776\n",
+            "           Dropout-7         [-1, 12, 197, 197]               0\n",
+            "            Linear-8             [-1, 197, 768]         590,592\n",
+            "           Dropout-9             [-1, 197, 768]               0\n",
+            "        Attention-10             [-1, 197, 768]               0\n",
+            "         Identity-11             [-1, 197, 768]               0\n",
+            "        LayerNorm-12             [-1, 197, 768]           1,536\n",
+            "           Linear-13            [-1, 197, 3072]       2,362,368\n",
+            "             GELU-14            [-1, 197, 3072]               0\n",
+            "          Dropout-15            [-1, 197, 3072]               0\n",
+            "           Linear-16             [-1, 197, 768]       2,360,064\n",
+            "          Dropout-17             [-1, 197, 768]               0\n",
+            "              Mlp-18             [-1, 197, 768]               0\n",
+            "         Identity-19             [-1, 197, 768]               0\n",
+            "            Block-20             [-1, 197, 768]               0\n",
+            "        LayerNorm-21             [-1, 197, 768]           1,536\n",
+            "           Linear-22            [-1, 197, 2304]       1,771,776\n",
+            "          Dropout-23         [-1, 12, 197, 197]               0\n",
+            "           Linear-24             [-1, 197, 768]         590,592\n",
+            "          Dropout-25             [-1, 197, 768]               0\n",
+            "        Attention-26             [-1, 197, 768]               0\n",
+            "         Identity-27             [-1, 197, 768]               0\n",
+            "        LayerNorm-28             [-1, 197, 768]           1,536\n",
+            "           Linear-29            [-1, 197, 3072]       2,362,368\n",
+            "             GELU-30            [-1, 197, 3072]               0\n",
+            "          Dropout-31            [-1, 197, 3072]               0\n",
+            "           Linear-32             [-1, 197, 768]       2,360,064\n",
+            "          Dropout-33             [-1, 197, 768]               0\n",
+            "              Mlp-34             [-1, 197, 768]               0\n",
+            "         Identity-35             [-1, 197, 768]               0\n",
+            "            Block-36             [-1, 197, 768]               0\n",
+            "        LayerNorm-37             [-1, 197, 768]           1,536\n",
+            "           Linear-38            [-1, 197, 2304]       1,771,776\n",
+            "          Dropout-39         [-1, 12, 197, 197]               0\n",
+            "           Linear-40             [-1, 197, 768]         590,592\n",
+            "          Dropout-41             [-1, 197, 768]               0\n",
+            "        Attention-42             [-1, 197, 768]               0\n",
+            "         Identity-43             [-1, 197, 768]               0\n",
+            "        LayerNorm-44             [-1, 197, 768]           1,536\n",
+            "           Linear-45            [-1, 197, 3072]       2,362,368\n",
+            "             GELU-46            [-1, 197, 3072]               0\n",
+            "          Dropout-47            [-1, 197, 3072]               0\n",
+            "           Linear-48             [-1, 197, 768]       2,360,064\n",
+            "          Dropout-49             [-1, 197, 768]               0\n",
+            "              Mlp-50             [-1, 197, 768]               0\n",
+            "         Identity-51             [-1, 197, 768]               0\n",
+            "            Block-52             [-1, 197, 768]               0\n",
+            "        LayerNorm-53             [-1, 197, 768]           1,536\n",
+            "           Linear-54            [-1, 197, 2304]       1,771,776\n",
+            "          Dropout-55         [-1, 12, 197, 197]               0\n",
+            "           Linear-56             [-1, 197, 768]         590,592\n",
+            "          Dropout-57             [-1, 197, 768]               0\n",
+            "        Attention-58             [-1, 197, 768]               0\n",
+            "         Identity-59             [-1, 197, 768]               0\n",
+            "        LayerNorm-60             [-1, 197, 768]           1,536\n",
+            "           Linear-61            [-1, 197, 3072]       2,362,368\n",
+            "             GELU-62            [-1, 197, 3072]               0\n",
+            "          Dropout-63            [-1, 197, 3072]               0\n",
+            "           Linear-64             [-1, 197, 768]       2,360,064\n",
+            "          Dropout-65             [-1, 197, 768]               0\n",
+            "              Mlp-66             [-1, 197, 768]               0\n",
+            "         Identity-67             [-1, 197, 768]               0\n",
+            "            Block-68             [-1, 197, 768]               0\n",
+            "        LayerNorm-69             [-1, 197, 768]           1,536\n",
+            "           Linear-70            [-1, 197, 2304]       1,771,776\n",
+            "          Dropout-71         [-1, 12, 197, 197]               0\n",
+            "           Linear-72             [-1, 197, 768]         590,592\n",
+            "          Dropout-73             [-1, 197, 768]               0\n",
+            "        Attention-74             [-1, 197, 768]               0\n",
+            "         Identity-75             [-1, 197, 768]               0\n",
+            "        LayerNorm-76             [-1, 197, 768]           1,536\n",
+            "           Linear-77            [-1, 197, 3072]       2,362,368\n",
+            "             GELU-78            [-1, 197, 3072]               0\n",
+            "          Dropout-79            [-1, 197, 3072]               0\n",
+            "           Linear-80             [-1, 197, 768]       2,360,064\n",
+            "          Dropout-81             [-1, 197, 768]               0\n",
+            "              Mlp-82             [-1, 197, 768]               0\n",
+            "         Identity-83             [-1, 197, 768]               0\n",
+            "            Block-84             [-1, 197, 768]               0\n",
+            "        LayerNorm-85             [-1, 197, 768]           1,536\n",
+            "           Linear-86            [-1, 197, 2304]       1,771,776\n",
+            "          Dropout-87         [-1, 12, 197, 197]               0\n",
+            "           Linear-88             [-1, 197, 768]         590,592\n",
+            "          Dropout-89             [-1, 197, 768]               0\n",
+            "        Attention-90             [-1, 197, 768]               0\n",
+            "         Identity-91             [-1, 197, 768]               0\n",
+            "        LayerNorm-92             [-1, 197, 768]           1,536\n",
+            "           Linear-93            [-1, 197, 3072]       2,362,368\n",
+            "             GELU-94            [-1, 197, 3072]               0\n",
+            "          Dropout-95            [-1, 197, 3072]               0\n",
+            "           Linear-96             [-1, 197, 768]       2,360,064\n",
+            "          Dropout-97             [-1, 197, 768]               0\n",
+            "              Mlp-98             [-1, 197, 768]               0\n",
+            "         Identity-99             [-1, 197, 768]               0\n",
+            "           Block-100             [-1, 197, 768]               0\n",
+            "       LayerNorm-101             [-1, 197, 768]           1,536\n",
+            "          Linear-102            [-1, 197, 2304]       1,771,776\n",
+            "         Dropout-103         [-1, 12, 197, 197]               0\n",
+            "          Linear-104             [-1, 197, 768]         590,592\n",
+            "         Dropout-105             [-1, 197, 768]               0\n",
+            "       Attention-106             [-1, 197, 768]               0\n",
+            "        Identity-107             [-1, 197, 768]               0\n",
+            "       LayerNorm-108             [-1, 197, 768]           1,536\n",
+            "          Linear-109            [-1, 197, 3072]       2,362,368\n",
+            "            GELU-110            [-1, 197, 3072]               0\n",
+            "         Dropout-111            [-1, 197, 3072]               0\n",
+            "          Linear-112             [-1, 197, 768]       2,360,064\n",
+            "         Dropout-113             [-1, 197, 768]               0\n",
+            "             Mlp-114             [-1, 197, 768]               0\n",
+            "        Identity-115             [-1, 197, 768]               0\n",
+            "           Block-116             [-1, 197, 768]               0\n",
+            "       LayerNorm-117             [-1, 197, 768]           1,536\n",
+            "          Linear-118            [-1, 197, 2304]       1,771,776\n",
+            "         Dropout-119         [-1, 12, 197, 197]               0\n",
+            "          Linear-120             [-1, 197, 768]         590,592\n",
+            "         Dropout-121             [-1, 197, 768]               0\n",
+            "       Attention-122             [-1, 197, 768]               0\n",
+            "        Identity-123             [-1, 197, 768]               0\n",
+            "       LayerNorm-124             [-1, 197, 768]           1,536\n",
+            "          Linear-125            [-1, 197, 3072]       2,362,368\n",
+            "            GELU-126            [-1, 197, 3072]               0\n",
+            "         Dropout-127            [-1, 197, 3072]               0\n",
+            "          Linear-128             [-1, 197, 768]       2,360,064\n",
+            "         Dropout-129             [-1, 197, 768]               0\n",
+            "             Mlp-130             [-1, 197, 768]               0\n",
+            "        Identity-131             [-1, 197, 768]               0\n",
+            "           Block-132             [-1, 197, 768]               0\n",
+            "       LayerNorm-133             [-1, 197, 768]           1,536\n",
+            "          Linear-134            [-1, 197, 2304]       1,771,776\n",
+            "         Dropout-135         [-1, 12, 197, 197]               0\n",
+            "          Linear-136             [-1, 197, 768]         590,592\n",
+            "         Dropout-137             [-1, 197, 768]               0\n",
+            "       Attention-138             [-1, 197, 768]               0\n",
+            "        Identity-139             [-1, 197, 768]               0\n",
+            "       LayerNorm-140             [-1, 197, 768]           1,536\n",
+            "          Linear-141            [-1, 197, 3072]       2,362,368\n",
+            "            GELU-142            [-1, 197, 3072]               0\n",
+            "         Dropout-143            [-1, 197, 3072]               0\n",
+            "          Linear-144             [-1, 197, 768]       2,360,064\n",
+            "         Dropout-145             [-1, 197, 768]               0\n",
+            "             Mlp-146             [-1, 197, 768]               0\n",
+            "        Identity-147             [-1, 197, 768]               0\n",
+            "           Block-148             [-1, 197, 768]               0\n",
+            "       LayerNorm-149             [-1, 197, 768]           1,536\n",
+            "          Linear-150            [-1, 197, 2304]       1,771,776\n",
+            "         Dropout-151         [-1, 12, 197, 197]               0\n",
+            "          Linear-152             [-1, 197, 768]         590,592\n",
+            "         Dropout-153             [-1, 197, 768]               0\n",
+            "       Attention-154             [-1, 197, 768]               0\n",
+            "        Identity-155             [-1, 197, 768]               0\n",
+            "       LayerNorm-156             [-1, 197, 768]           1,536\n",
+            "          Linear-157            [-1, 197, 3072]       2,362,368\n",
+            "            GELU-158            [-1, 197, 3072]               0\n",
+            "         Dropout-159            [-1, 197, 3072]               0\n",
+            "          Linear-160             [-1, 197, 768]       2,360,064\n",
+            "         Dropout-161             [-1, 197, 768]               0\n",
+            "             Mlp-162             [-1, 197, 768]               0\n",
+            "        Identity-163             [-1, 197, 768]               0\n",
+            "           Block-164             [-1, 197, 768]               0\n",
+            "       LayerNorm-165             [-1, 197, 768]           1,536\n",
+            "          Linear-166            [-1, 197, 2304]       1,771,776\n",
+            "         Dropout-167         [-1, 12, 197, 197]               0\n",
+            "          Linear-168             [-1, 197, 768]         590,592\n",
+            "         Dropout-169             [-1, 197, 768]               0\n",
+            "       Attention-170             [-1, 197, 768]               0\n",
+            "        Identity-171             [-1, 197, 768]               0\n",
+            "       LayerNorm-172             [-1, 197, 768]           1,536\n",
+            "          Linear-173            [-1, 197, 3072]       2,362,368\n",
+            "            GELU-174            [-1, 197, 3072]               0\n",
+            "         Dropout-175            [-1, 197, 3072]               0\n",
+            "          Linear-176             [-1, 197, 768]       2,360,064\n",
+            "         Dropout-177             [-1, 197, 768]               0\n",
+            "             Mlp-178             [-1, 197, 768]               0\n",
+            "        Identity-179             [-1, 197, 768]               0\n",
+            "           Block-180             [-1, 197, 768]               0\n",
+            "       LayerNorm-181             [-1, 197, 768]           1,536\n",
+            "          Linear-182            [-1, 197, 2304]       1,771,776\n",
+            "         Dropout-183         [-1, 12, 197, 197]               0\n",
+            "          Linear-184             [-1, 197, 768]         590,592\n",
+            "         Dropout-185             [-1, 197, 768]               0\n",
+            "       Attention-186             [-1, 197, 768]               0\n",
+            "        Identity-187             [-1, 197, 768]               0\n",
+            "       LayerNorm-188             [-1, 197, 768]           1,536\n",
+            "          Linear-189            [-1, 197, 3072]       2,362,368\n",
+            "            GELU-190            [-1, 197, 3072]               0\n",
+            "         Dropout-191            [-1, 197, 3072]               0\n",
+            "          Linear-192             [-1, 197, 768]       2,360,064\n",
+            "         Dropout-193             [-1, 197, 768]               0\n",
+            "             Mlp-194             [-1, 197, 768]               0\n",
+            "        Identity-195             [-1, 197, 768]               0\n",
+            "           Block-196             [-1, 197, 768]               0\n",
+            "       LayerNorm-197             [-1, 197, 768]           1,536\n",
+            "        Identity-198                  [-1, 768]               0\n",
+            "          Linear-199                 [-1, 1000]         769,000\n",
+            "================================================================\n",
+            "Total params: 86,415,592\n",
+            "Trainable params: 86,415,592\n",
+            "Non-trainable params: 0\n",
+            "----------------------------------------------------------------\n",
+            "Input size (MB): 0.57\n",
+            "Forward/backward pass size (MB): 408.54\n",
+            "Params size (MB): 329.65\n",
+            "Estimated Total Size (MB): 738.77\n",
+            "----------------------------------------------------------------\n",
+            "cuda:0\n",
+            "Model loaded correctly\n",
+            "Testing phase start...\n"
           ]
         }
       ]
@@ -5590,38 +6338,105 @@
         "y_pred= np.argmax(scores,1)\n",
         "categories = [\"anger\",\"contempt\",\"disgust\",\"fear\",\"happy\",\"neutral\",\"sadness\",\"surprise\"]\n",
         "\n",
-        "\n",
-        "#labels = train_ds.features['label'].names\n",
+        "# labels = train_ds.features['label'].names\n",
         "cm = confusion_matrix(y_true, y_pred)\n",
         "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=categories)\n",
         "disp.plot(xticks_rotation=45)"
       ],
       "metadata": {
-        "id": "BXW3lMs_R_oB"
+        "id": "BXW3lMs_R_oB",
+        "outputId": "f19891b2-a0ad-452a-e3f4-b670a890dc2f",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 329
+        }
       },
-      "execution_count": null,
+      "execution_count": 218,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<sklearn.metrics._plot.confusion_matrix.ConfusionMatrixDisplay at 0x7f39c2a7b650>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 218
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 432x288 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "test_accuracy_8 = accuracy_score(y_true, y_pred, normalize=True)\n",
+        "print('Test Accuracy on AffectNet with 8-classes: {}'.format(round(test_accuracy_8,4)))"
+      ],
+      "metadata": {
+        "id": "WAyzleCUbsr1",
+        "outputId": "fdd8de23-0b56-4af7-d080-be3df06a0027",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": 213,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Test Accuracy on AffectNet with 8-classes: 0.531\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "y_true_7 = []\n",
+        "y_pred_7 = []\n",
+        "for i in range(len(y_true)):\n",
+        "  if y_true[i] != 1:\n",
+        "    y_true_7.append(y_true[i])\n",
+        "    y_pred_7.append(y_pred[i])"
+      ],
+      "metadata": {
+        "id": "i2YEjPBtbpWV"
+      },
+      "execution_count": 214,
       "outputs": []
     },
     {
       "cell_type": "code",
       "source": [
-        "test_accuracy = accuracy_score(y_true, y_pred, normalize=True)\n",
-        "print('Test Accuracy on AffectNet: {}'.format(test_accuracy))"
+        "test_accuracy_7 = accuracy_score(y_true_7, y_pred_7, normalize=True)\n",
+        "print('Test Accuracy on AffectNet with 7-classes: {}'.format(round(test_accuracy_7,4)))"
       ],
       "metadata": {
         "id": "i9wIFDFPHJv5",
-        "outputId": "28099a26-0a38-4f80-abec-56e8bd74c097",
+        "outputId": "5d0288b0-7598-46f3-c282-e324a2c2309c",
         "colab": {
           "base_uri": "https://localhost:8080/"
         }
       },
-      "execution_count": null,
+      "execution_count": 215,
       "outputs": [
         {
           "output_type": "stream",
           "name": "stdout",
           "text": [
-            "Test Accuracy on AffectNet: 0.53525\n"
+            "Test Accuracy on AffectNet with 7-classes: 0.5694\n"
           ]
         }
       ]
@@ -5633,12 +6448,12 @@
       ],
       "metadata": {
         "id": "5jp-cHE8MTyl",
-        "outputId": "a421e064-8f05-42ca-e617-d866b5d7483e",
+        "outputId": "a5074f05-cf6e-42f5-c3c5-89b8c872da73",
         "colab": {
           "base_uri": "https://localhost:8080/"
         }
       },
-      "execution_count": null,
+      "execution_count": 216,
       "outputs": [
         {
           "output_type": "stream",
@@ -5646,18 +6461,18 @@
           "text": [
             "              precision    recall  f1-score   support\n",
             "\n",
-            "       anger     0.4590    0.5600    0.5045       500\n",
-            "    contempt     0.5930    0.3060    0.4037       500\n",
-            "     disgust     0.6389    0.3680    0.4670       500\n",
-            "        fear     0.6280    0.5740    0.5998       500\n",
-            "       happy     0.6045    0.8040    0.6901       500\n",
-            "     neutral     0.4058    0.5340    0.4611       500\n",
-            "     sadness     0.5479    0.5720    0.5597       500\n",
-            "    surprise     0.5203    0.5640    0.5413       500\n",
+            "       anger     0.4622    0.5380    0.4972       500\n",
+            "    contempt     0.6037    0.2620    0.3654       500\n",
+            "     disgust     0.6401    0.3700    0.4689       500\n",
+            "        fear     0.6302    0.5760    0.6019       500\n",
+            "       happy     0.5959    0.8080    0.6859       500\n",
+            "     neutral     0.4012    0.5320    0.4574       500\n",
+            "     sadness     0.5323    0.5940    0.5614       500\n",
+            "    surprise     0.5108    0.5680    0.5379       500\n",
             "\n",
-            "    accuracy                         0.5353      4000\n",
-            "   macro avg     0.5497    0.5353    0.5284      4000\n",
-            "weighted avg     0.5497    0.5353    0.5284      4000\n",
+            "    accuracy                         0.5310      4000\n",
+            "   macro avg     0.5470    0.5310    0.5220      4000\n",
+            "weighted avg     0.5470    0.5310    0.5220      4000\n",
             "\n"
           ]
         }