Facial_Emotion_Classification_Task.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "05e13074",
   "metadata": {
    "id": "05e13074"
   },
   "source": [
    "## Using MLP"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ioSIMBftCvr",
   "metadata": {
    "id": "1ioSIMBftCvr"
   },
   "source": [
    "### Unzipping imported data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "SpdKyBgga9h4",
   "metadata": {
    "id": "SpdKyBgga9h4"
   },
   "outputs": [],
   "source": [
    "# !unzip Dataset.zip -d Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ZPTNkk3aBQJV",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ZPTNkk3aBQJV",
    "outputId": "a36ba041-4fac-4ee1-a58c-97a1d9b6308a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--2022-01-22 16:50:36--  https://raw.githubusercontent.com/udacity/deep-learning-v2-pytorch/master/intro-to-pytorch/helper.py\n",
      "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.109.133, 185.199.108.133, 185.199.111.133, ...\n",
      "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.109.133|:443... connected.\n",
      "HTTP request sent, awaiting response... 200 OK\n",
      "Length: 2813 (2.7K) [text/plain]\n",
      "Saving to: ‘helper.py’\n",
      "\n",
      "\r",
      "helper.py             0%[                    ]       0  --.-KB/s               \r",
      "helper.py           100%[===================>]   2.75K  --.-KB/s    in 0s      \n",
      "\n",
      "2022-01-22 16:50:36 (34.3 MB/s) - ‘helper.py’ saved [2813/2813]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "!wget -c https://raw.githubusercontent.com/udacity/deep-learning-v2-pytorch/master/intro-to-pytorch/helper.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c664b204",
   "metadata": {
    "id": "c664b204"
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from random import randint\n",
    "import utils\n",
    "import utils1\n",
    "from torchvision import datasets, transforms\n",
    "import matplotlib.pyplot as plt\n",
    "import time\n",
    "import Dataset\n",
    "import helper"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82adc0e1",
   "metadata": {
    "id": "82adc0e1"
   },
   "source": [
    "### Transforming the input data to suitable format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7f19905",
   "metadata": {
    "id": "b7f19905"
   },
   "outputs": [],
   "source": [
    "mean = [0.5077]\n",
    "std = [0.2120]\n",
    "\n",
    "\n",
    "data_dir  = '/content/Dataset/Dataset'\n",
    "\n",
    "#transforming train data\n",
    "train_transform = transforms.Compose([transforms.Resize((48,48)),\n",
    "    transforms.RandomHorizontalFlip(),\n",
    "    transforms.Grayscale(num_output_channels=1),\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize(torch.Tensor(mean), torch.Tensor(std))])\n",
    "\n",
    "train_dataset = datasets.ImageFolder(data_dir + '/train', transform=train_transform)\n",
    "train_data =  torch.utils.data.DataLoader(train_dataset, batch_size = 100, shuffle= True)# divides the data into (total_images/bs) batches after shuffling\n",
    "\n",
    "#transforming test data\n",
    "test_transform = transforms.Compose([transforms.Resize((48,48)),\n",
    "    transforms.RandomHorizontalFlip(),\n",
    "    transforms.Grayscale(num_output_channels=1),\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize(torch.Tensor(mean), torch.Tensor(std))])\n",
    "\n",
    "test_dataset = datasets.ImageFolder(data_dir + '/test', transform=test_transform)\n",
    "test_data =  torch.utils.data.DataLoader(test_dataset, batch_size = 100, shuffle= True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "afae2b5c",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "afae2b5c",
    "outputId": "19adba2f-6e83-4787-d2f2-2643f70a46b2",
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7178"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(test_dataset) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c4589b56",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "c4589b56",
    "outputId": "0d196818-39bb-470a-b8a3-e43097a4c4f8",
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28709"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(train_dataset)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "hJbeRP6GapX2",
   "metadata": {
    "id": "hJbeRP6GapX2"
   },
   "source": [
    "### Code to find the mean and std of the pictures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d80e83c",
   "metadata": {
    "id": "9d80e83c"
   },
   "outputs": [],
   "source": [
    "\"\"\"def get_mean_and_std(loader):\n",
    "    mean = 0.\n",
    "    std = 0.\n",
    "    total_images_count = 0\n",
    "    for images,_ in loader:\n",
    "        image_count_in_a_batch = images.size(0)\n",
    "        images = images.view(image_count_in_a_batch, images.size(1), -1)\n",
    "        mean += images.mean(2).sum(0)\n",
    "        std += images.std(2).sum(0)\n",
    "        total_images_count += image_count_in_a_batch\n",
    "    \n",
    "    mean /= total_images_count\n",
    "    std /= total_images_count\n",
    "    \n",
    "    return mean,std\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82bf6d48",
   "metadata": {
    "id": "82bf6d48",
    "outputId": "a74df3a8-87cb-4d61-d617-15603d200a40"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([0.5077]), tensor([0.2120]))"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#get_mean_and_std(train_loader)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1aea4f2",
   "metadata": {
    "id": "f1aea4f2"
   },
   "source": [
    "### Contructing a Three-layer neural net "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cd2855e0",
   "metadata": {
    "id": "cd2855e0"
   },
   "outputs": [],
   "source": [
    "class three_layer_net(nn.Module):\n",
    "    def __init__(self,input_size,hidden_size1,hidden_size2,output_size):\n",
    "        super(three_layer_net,self).__init__()\n",
    "        \n",
    "        self.layer1 = nn.Linear( input_size , hidden_size1, bias=True)\n",
    "        self.layer2 = nn.Linear( hidden_size1 , hidden_size2, bias=True)\n",
    "        self.layer3 = nn.Linear( hidden_size2, output_size, bias = True)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        y       = self.layer1(x)\n",
    "        y_hat   = torch.relu(y)\n",
    "        z       = self.layer2(y_hat)\n",
    "        z_hat   = torch.relu(z) \n",
    "        scores  = self.layer3(z_hat)\n",
    "        \n",
    "        return scores"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d61684b",
   "metadata": {
    "id": "0d61684b"
   },
   "source": [
    "### Building the neural net using the template contructed above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27e583f4",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "27e583f4",
    "outputId": "87f6f687-073f-4243-b026-58c8e3b06118"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "three_layer_net(\n",
      "  (layer1): Linear(in_features=2304, out_features=100, bias=True)\n",
      "  (layer2): Linear(in_features=100, out_features=100, bias=True)\n",
      "  (layer3): Linear(in_features=100, out_features=7, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "neural_net = three_layer_net(2304,100,100,7)\n",
    "neural_net.to(\"cuda\")   #transferring the neural net onto the GPU\n",
    "print(neural_net)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "_ZrK3b2arllK",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "_ZrK3b2arllK",
    "outputId": "94e4c167-8050-424c-c68f-3afe97b09396"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda:0  layer1.weight\n",
      "cuda:0  layer1.bias\n",
      "cuda:0  layer2.weight\n",
      "cuda:0  layer2.bias\n",
      "cuda:0  layer3.weight\n",
      "cuda:0  layer3.bias\n"
     ]
    }
   ],
   "source": [
    "for n, p in neural_net.named_parameters():    #checking whether the neural net is transferred onto the gpu\n",
    "    print(p.device, '', n)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "119e0403",
   "metadata": {
    "id": "119e0403"
   },
   "source": [
    "### Selecting loss,optimizer batch size, learning rate "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5ce6c84d",
   "metadata": {
    "id": "5ce6c84d"
   },
   "outputs": [],
   "source": [
    "#Selecting the loss function\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "#Selecting the optimizer\n",
    "optimizer = torch.optim.SGD( neural_net.parameters() , lr=0.03 ) \n",
    "#Defining batch size\n",
    "bs= 100"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff7e5bac",
   "metadata": {
    "id": "ff7e5bac"
   },
   "source": [
    "### Evaluates on test data and gives error "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75675a65",
   "metadata": {
    "id": "75675a65"
   },
   "outputs": [],
   "source": [
    "def eval_on_test_set():\n",
    "\n",
    "    running_error=0\n",
    "    num_batches=0\n",
    "\n",
    "    for i in range(0,7178,bs):\n",
    "\n",
    "        test_data =  torch.utils.data.DataLoader(test_dataset, batch_size = bs, shuffle= True)\n",
    "        test_images,test_labels = next(iter(train_data))\n",
    "        test_images = test_images.view(bs,48,48)\n",
    "\n",
    "        inputs = test_images.view(bs,2304)\n",
    "\n",
    "        scores = neural_net( inputs.to(\"cuda\") ) \n",
    "\n",
    "        error = utils.get_error(scores ,test_labels)\n",
    "\n",
    "        running_error += error.item()\n",
    "\n",
    "        num_batches+=1\n",
    "\n",
    "\n",
    "    total_error = running_error/num_batches\n",
    "    print( 'test error  = ', total_error*100 ,'percent')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "407cb5a7",
   "metadata": {
    "id": "407cb5a7"
   },
   "source": [
    "### Training the neural network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a46a5cf5",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "a46a5cf5",
    "outputId": "692ff6b1-abbd-440b-907c-2ec50c3f9766"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " \n",
      "epoch= 0 \t time= 17.021608591079712 \t error= 67.61111172123087 percent\n",
      " \n",
      "epoch= 10 \t time= 182.33561038970947 \t error= 53.66666751603285 percent\n",
      " \n",
      "epoch= 20 \t time= 347.36742782592773 \t error= 47.5972230028775 percent\n",
      " \n",
      "epoch= 30 \t time= 513.3918793201447 \t error= 43.079862371087074 percent\n",
      " \n",
      "epoch= 40 \t time= 679.1966776847839 \t error= 38.95486241413487 percent\n",
      " \n",
      "epoch= 50 \t time= 844.6388919353485 \t error= 35.03819598505895 percent\n",
      " \n",
      "epoch= 60 \t time= 1009.836630821228 \t error= 31.41666826688581 percent\n",
      " \n",
      "epoch= 70 \t time= 1174.8324837684631 \t error= 29.28472397228082 percent\n",
      " \n",
      "epoch= 80 \t time= 1339.9887599945068 \t error= 26.378474032713306 percent\n",
      " \n",
      "epoch= 90 \t time= 1504.6522347927094 \t error= 24.395835171971054 percent\n",
      " \n",
      "epoch= 100 \t time= 1668.7860000133514 \t error= 22.013890950216187 percent\n",
      " \n",
      "epoch= 110 \t time= 1833.3005211353302 \t error= 19.892363250255585 percent\n",
      " \n",
      "epoch= 120 \t time= 1997.8555572032928 \t error= 18.038196654783356 percent\n",
      " \n",
      "epoch= 130 \t time= 2163.211751937866 \t error= 17.187502028213608 percent\n",
      " \n",
      "epoch= 140 \t time= 2327.9604370594025 \t error= 16.538196533090538 percent\n",
      " \n",
      "epoch= 150 \t time= 2493.103755235672 \t error= 14.565974122120274 percent\n",
      " \n",
      "epoch= 160 \t time= 2657.483477115631 \t error= 13.111113156709406 percent\n",
      " \n",
      "epoch= 170 \t time= 2822.0924882888794 \t error= 12.46180749601788 percent\n",
      " \n",
      "epoch= 180 \t time= 2986.485190153122 \t error= 11.802085240681965 percent\n",
      " \n",
      "epoch= 190 \t time= 3150.9332106113434 \t error= 10.791668626997206 percent\n",
      " \n",
      "epoch= 200 \t time= 3314.937009334564 \t error= 4.579863241977162 percent\n",
      " \n",
      "epoch= 210 \t time= 3478.219296693802 \t error= 2.2013919634951487 percent\n",
      " \n",
      "epoch= 220 \t time= 3642.443558692932 \t error= 1.7777810287144449 percent\n",
      " \n",
      "epoch= 230 \t time= 3806.9898607730865 \t error= 1.381947762436337 percent\n",
      " \n",
      "epoch= 240 \t time= 3971.9321281909943 \t error= 1.2986141981350052 percent\n",
      " \n",
      "epoch= 250 \t time= 4136.75358915329 \t error= 1.1388919833633635 percent\n",
      " \n",
      "epoch= 260 \t time= 4301.760255098343 \t error= 1.0659750344024765 percent\n",
      " \n",
      "epoch= 270 \t time= 4465.425120830536 \t error= 0.8923636749386787 percent\n",
      " \n",
      "epoch= 280 \t time= 4629.938741207123 \t error= 0.8159749209880829 percent\n",
      " \n",
      "epoch= 290 \t time= 4794.022003173828 \t error= 0.750002409848902 percent\n"
     ]
    }
   ],
   "source": [
    "start = time.time()\n",
    "\n",
    "for epoch in range(300):\n",
    "    \n",
    "    if epoch == 200:\n",
    "      optimizer = torch.optim.SGD( neural_net.parameters() , lr=0.006 )   # it was observed that the error starts increasing with a lr of 0.03 after 200 epochs\n",
    "\n",
    "\n",
    "    running_error=0\n",
    "    num_batches=0\n",
    "    \n",
    "    \n",
    "    for count in range(0,28709,bs):\n",
    "        \n",
    "        # forward and backward pass\n",
    "    \n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        batch_images,batch_labels = next(iter(train_data))     #everytime next() function is called it moves to the next batch and therefore iterates throughout the train_data set\n",
    "        batch_images = batch_images.view(bs,48,48)\n",
    "\n",
    "        inputs = batch_images.view(bs,2304)\n",
    "\n",
    "        inputs.requires_grad_()\n",
    "\n",
    "        scores= neural_net(inputs.to(\"cuda\")) \n",
    "\n",
    "        loss =  criterion(scores ,batch_labels.to(\"cuda\")) \n",
    "        \n",
    "        loss.backward()\n",
    "\n",
    "        optimizer.step()\n",
    "        \n",
    "        \n",
    "        # compute some stats\n",
    "     \n",
    "        error = utils.get_error( scores.detach() , batch_labels.to(\"cuda\"))\n",
    "        running_error += error.item()\n",
    "        \n",
    "        num_batches+=1\n",
    "    \n",
    "    \n",
    "    # once the epoch is finished we divide the \"running quantities\"\n",
    "    # by the number of batches\n",
    "    \n",
    "    total_error = running_error/num_batches\n",
    "    elapsed_time = time.time() - start\n",
    "    \n",
    "    # every 10 epoch we display the stats \n",
    "    # and compute the error rate on the test set  \n",
    "    \n",
    "    if epoch % 10 == 0 : \n",
    "    \n",
    "        print(' ')\n",
    "        \n",
    "        print('epoch=',epoch, '\\t time=', elapsed_time,'\\t error=', total_error*100 ,'percent') \n",
    "               "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "84-xfYBetakp",
   "metadata": {
    "id": "84-xfYBetakp"
   },
   "outputs": [],
   "source": [
    "eval_on_test_set()  #checks error on test set, if error on test is more than train then check for over-fitting"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2V-kPwLwEsIi",
   "metadata": {
    "id": "2V-kPwLwEsIi"
   },
   "source": [
    "###Displaying the test image and the respective classification by the neural net"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b298c9f",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 515
    },
    "id": "4b298c9f",
    "outputId": "3b54e81d-fcac-406a-eb43-3ba2a0d86a64"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import utils1\n",
    "neural_net.to('cpu')\n",
    "\n",
    "indx = randint(0,7178-1)\n",
    "images, labels = next(iter(test_data))\n",
    "im = images[0]\n",
    "\n",
    "arr = images[0].numpy()\n",
    "arr_ = np.squeeze(arr) \n",
    "plt.imshow(arr_)\n",
    "plt.show()\n",
    "with torch.no_grad():\n",
    "  scores = neural_net(im.view(1,2304))\n",
    "  prob=torch.softmax(scores, dim = 1)\n",
    "\n",
    "prob = prob.view(7).numpy().tolist()     #converting the probabilities array into \n",
    "\n",
    "classes = [\"angry\",\"disgust\",\"fear\", \"happy\", \"neutral\", \"sad\", \"surprise\"]\n",
    "\n",
    "\n",
    "plt.barh(classes, prob)\n",
    " \n",
    "# setting label of y-axis\n",
    "plt.ylabel(\"classes\")\n",
    " \n",
    "# setting label of x-axis\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "I76GPa5tyq_X",
   "metadata": {
    "id": "I76GPa5tyq_X"
   },
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "xZOGC_STyGiX",
   "metadata": {
    "id": "xZOGC_STyGiX"
   },
   "source": [
    "## Using CNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "mUmE25UfOL8i",
   "metadata": {
    "id": "mUmE25UfOL8i"
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import torchvision\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from torchvision import datasets, transforms\n",
    "from torch.utils.data import DataLoader\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import torch\n",
    "import utils\n",
    "\n",
    "import pandas as pd\n",
    "from torch.autograd import Variable\n",
    "from torch.nn import Linear, ReLU, CrossEntropyLoss, Sequential, Conv2d, MaxPool2d, Module, Softmax, BatchNorm2d, Dropout\n",
    "from torch.optim import Adam, SGD"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "-pTWQcIYcG_-",
   "metadata": {
    "id": "-pTWQcIYcG_-"
   },
   "source": [
    "**Calculating Mean and Standard Deviation**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "Muvb5RZ-cNkR",
   "metadata": {
    "id": "Muvb5RZ-cNkR"
   },
   "outputs": [],
   "source": [
    "# def get_mean_and_std(loader):\n",
    "#   mean=0\n",
    "#   std=0\n",
    "#   tot_images_count=0\n",
    "#   for images, _ in loader:\n",
    "#     image_count_in_a_batch = images.size(0)\n",
    "#     # print(images.shape)\n",
    "#     images = images.view(image_count_in_a_batch, images.size(1), -1)\n",
    "#     mean += images .mean(2).sum(0)\n",
    "#     std += images.std(2).sum(0)\n",
    "#     tot_images_count += image_count_in_a_batch\n",
    "#   mean /= tot_images_count\n",
    "#   std /= tot_images_count\n",
    "\n",
    "#   return mean, std\n",
    "  \n",
    "# get_mean_and_std(train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "IN4QEdjCOTUn",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 358,
     "status": "ok",
     "timestamp": 1642867190373,
     "user": {
      "displayName": "Sayandeep Ghosh",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GhWbi6vmkcAJ8Wto5FqFEjJhfKJ15-45rQCkTbN1A=s64",
      "userId": "18045142520943844949"
     },
     "user_tz": -330
    },
    "id": "IN4QEdjCOTUn",
    "outputId": "0ee7fe73-3f60-441b-ef80-862d0730d360"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "288\n",
      "72\n",
      "28709\n",
      "7178\n"
     ]
    }
   ],
   "source": [
    "mean =[0.5334, 0.5334, 0.5334]\n",
    "std = [0.1774, 0.1774, 0.1774]\n",
    "\n",
    "data_dir = '/content/Dataset/Dataset'\n",
    "transform = transforms.Compose([\n",
    "        #transforms.RandomRotation(20),\n",
    "        transforms.RandomResizedCrop(128),\n",
    "        #transforms.RandomHorizontalFlip(),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize(torch.Tensor(mean),torch.Tensor(std))])\n",
    "batch_size = 100\n",
    "train_set = datasets.ImageFolder(data_dir + '/train',transform = transform)\n",
    "test_set =  datasets.ImageFolder(data_dir + '/test',transform = transform)\n",
    "\n",
    "train = torch.utils.data.DataLoader(train_set,batch_size =batch_size,shuffle=True,num_workers=2)\n",
    "test = torch.utils.data.DataLoader(test_set,batch_size =batch_size,shuffle=True,num_workers=2)\n",
    "\n",
    "classes = ('angry', 'disgust', 'fear', 'happy','neutral', 'sad', 'surprise')\n",
    "\n",
    "print(len(train))\n",
    "print(len(test))\n",
    "print(len(train_set))\n",
    "print(len(test_set))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aNHZDLcMT_eR",
   "metadata": {
    "id": "aNHZDLcMT_eR"
   },
   "source": [
    "**Checking If its loaded properly**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "795-KByFOYy2",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 324
    },
    "executionInfo": {
     "elapsed": 1993,
     "status": "ok",
     "timestamp": 1642867199293,
     "user": {
      "displayName": "Sayandeep Ghosh",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GhWbi6vmkcAJ8Wto5FqFEjJhfKJ15-45rQCkTbN1A=s64",
      "userId": "18045142520943844949"
     },
     "user_tz": -330
    },
    "id": "795-KByFOYy2",
    "outputId": "7c72d8f5-fb5c-46e1-8b12-2d8c93b6b014"
   },
   "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"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "neutral neutral happy happy happy fear  surprise disgust fear  angry fear  fear  neutral surprise fear  neutral surprise angry neutral fear  happy angry happy fear  sad   surprise happy fear  neutral neutral surprise sad   fear  sad   neutral sad   surprise happy sad   angry neutral angry fear  happy surprise surprise sad   happy fear  surprise angry angry neutral disgust angry neutral sad   fear  happy angry fear  neutral sad   sad   happy happy neutral happy surprise happy sad   happy happy angry sad   sad   fear  sad   sad   neutral angry neutral happy surprise neutral sad   happy angry surprise sad   neutral surprise fear  happy sad   happy surprise sad   angry happy\n"
     ]
    }
   ],
   "source": [
    "def imshow(img):\n",
    "    img = img / 2 + 0.5     # unnormalize\n",
    "    npimg = img.numpy()\n",
    "    plt.imshow(np.transpose(npimg, (1, 2, 0)))\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "# get some random training images\n",
    "dataiter = iter(train)\n",
    "images, labels = dataiter.next()\n",
    "\n",
    "# show images\n",
    "imshow(torchvision.utils.make_grid(images))\n",
    "# print labels\n",
    "print(' '.join(f'{classes[labels[j]]:5s}' for j in range(batch_size)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6DQ3-knOUIwl",
   "metadata": {
    "id": "6DQ3-knOUIwl"
   },
   "source": [
    "**Preparing The CNN Training Net**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "EB329s4wOiU8",
   "metadata": {
    "id": "EB329s4wOiU8"
   },
   "outputs": [],
   "source": [
    "class LeNet_convnet(nn.Module):\n",
    "\n",
    "    def __init__(self):\n",
    "\n",
    "        super(LeNet5_convnet, self).__init__() \n",
    "        self.conv1 = nn.Conv2d(3,  50,  kernel_size=3,  padding=1 )\n",
    "        BatchNorm2d(6)\n",
    "        self.pool1  = nn.MaxPool2d(2,2)\n",
    "        self.conv2 = nn.Conv2d(50,  100,  kernel_size=3,  padding=1 )\n",
    "        BatchNorm2d(100)\n",
    "        self.pool2 = nn.MaxPool2d(2,2)\n",
    "        self.conv3 = nn.Conv2d(100,  200,  kernel_size=3,  padding=1 )\n",
    "        BatchNorm2d(200)\n",
    "        self.pool3 = nn.MaxPool2d(2,2)\n",
    "\n",
    "        # linear layers\n",
    "        self.linear1 = nn.Linear(51200, 500)\n",
    "        self.linear2 = nn.Linear(500,200)\n",
    "        self.linear3 = nn.Linear(200,50)\n",
    "        self.linear4 = nn.Linear(50,7)\n",
    "        self.dropout = nn.Dropout(0.25)\n",
    "\n",
    "\n",
    "    def forward(self, x):\n",
    "\n",
    "        x = self.conv1(x)\n",
    "        x = torch.relu(x)\n",
    "        x = self.pool1(x)\n",
    "        x = self.conv2(x)\n",
    "        x = torch.relu(x)\n",
    "        x = self.pool2(x)\n",
    "        x = self.conv3(x)\n",
    "        x = torch.relu(x)\n",
    "        x = self.pool3(x)\n",
    "        x = x.view(-1, 51200)\n",
    "        # x = torch.flatten(x, 1)\n",
    "        x = self.linear1(x)\n",
    "        x = torch.relu(x)\n",
    "        x = self.linear2(x)\n",
    "        x = torch.relu(x)\n",
    "        x = self.linear3(x)\n",
    "        x = torch.relu(x)\n",
    "        x = self.dropout(x)\n",
    "        x = self.linear4(x)\n",
    "    \n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "oG7gdohaROF5",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 411,
     "status": "ok",
     "timestamp": 1642868760992,
     "user": {
      "displayName": "Sayandeep Ghosh",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GhWbi6vmkcAJ8Wto5FqFEjJhfKJ15-45rQCkTbN1A=s64",
      "userId": "18045142520943844949"
     },
     "user_tz": -330
    },
    "id": "oG7gdohaROF5",
    "outputId": "49a51ebd-6dd3-4ab9-8e79-cc6c0f8b5065"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LeNet5_convnet(\n",
      "  (conv1): Conv2d(3, 50, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "  (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "  (conv2): Conv2d(50, 100, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "  (pool2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "  (conv3): Conv2d(100, 200, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "  (pool3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "  (linear1): Linear(in_features=51200, out_features=500, bias=True)\n",
      "  (linear2): Linear(in_features=500, out_features=200, bias=True)\n",
      "  (linear3): Linear(in_features=200, out_features=50, bias=True)\n",
      "  (linear4): Linear(in_features=50, out_features=7, bias=True)\n",
      "  (dropout): Dropout(p=0.25, inplace=False)\n",
      ")\n",
      "There are 25937807 (25.94 million) parameters in this neural network\n"
     ]
    }
   ],
   "source": [
    "net=LeNet5_convnet()\n",
    "# net = Net()\n",
    "print(net)\n",
    "utils.display_num_param(net)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "NcqSiwGWUR6m",
   "metadata": {
    "id": "NcqSiwGWUR6m"
   },
   "source": [
    "**Checking availability of GPU** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "kmXdGhYjRYNz",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 367,
     "status": "ok",
     "timestamp": 1642868764017,
     "user": {
      "displayName": "Sayandeep Ghosh",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GhWbi6vmkcAJ8Wto5FqFEjJhfKJ15-45rQCkTbN1A=s64",
      "userId": "18045142520943844949"
     },
     "user_tz": -330
    },
    "id": "kmXdGhYjRYNz",
    "outputId": "bb366eaa-dfc9-4e12-e6a2-edaf21426da6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda:0\n"
     ]
    }
   ],
   "source": [
    "device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\n",
    "\n",
    "# Assuming that we are on a CUDA machine, this should print a CUDA device:\n",
    "\n",
    "print(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "W32KnNKtUgbO",
   "metadata": {
    "id": "W32KnNKtUgbO"
   },
   "source": [
    "**Send the weights of the networks to the GPU as well as choosing the criterion and learning rate** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "HYJxCpfBV56C",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 348,
     "status": "ok",
     "timestamp": 1642868766615,
     "user": {
      "displayName": "Sayandeep Ghosh",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GhWbi6vmkcAJ8Wto5FqFEjJhfKJ15-45rQCkTbN1A=s64",
      "userId": "18045142520943844949"
     },
     "user_tz": -330
    },
    "id": "HYJxCpfBV56C",
    "outputId": "35d82d34-43f7-459b-a031-bfe42b67d204"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LeNet5_convnet(\n",
       "  (conv1): Conv2d(3, 50, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  (conv2): Conv2d(50, 100, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (pool2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  (conv3): Conv2d(100, 200, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (pool3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  (linear1): Linear(in_features=51200, out_features=500, bias=True)\n",
       "  (linear2): Linear(in_features=500, out_features=200, bias=True)\n",
       "  (linear3): Linear(in_features=200, out_features=50, bias=True)\n",
       "  (linear4): Linear(in_features=50, out_features=7, bias=True)\n",
       "  (dropout): Dropout(p=0.25, inplace=False)\n",
       ")"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch.optim as optim\n",
    "\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.SGD(net.parameters(), lr=0.01,momentum = 0.9)\n",
    "\n",
    "if torch.cuda.is_available(): # Checking if we can use GPU\n",
    "    net = net.cuda()\n",
    "    criterion = criterion.cuda()\n",
    "net.to(device)\n",
    "# print(net)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "B7JQRwePUyBa",
   "metadata": {
    "id": "B7JQRwePUyBa"
   },
   "source": [
    "**Training the network**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "XIoVwV6bV7-y",
   "metadata": {
    "id": "XIoVwV6bV7-y"
   },
   "outputs": [],
   "source": [
    "def train_net(n_epoch): # Training our network\n",
    "    losses = []\n",
    "    for epoch in range(n_epoch):  # loop over the dataset multiple times\n",
    "        running_loss = 0.0\n",
    "        for i, data in enumerate(train, 0):\n",
    "            # get the inputs; data is a list of [inputs, labels]\n",
    "            # inputs, labels = data\n",
    "            inputs, labels = data[0].to(device), data[1].to(device)\n",
    "            # zero the parameter gradients\n",
    "            optimizer.zero_grad()\n",
    "\n",
    "            # forward + backward + optimize\n",
    "            outputs = net(inputs)\n",
    "            loss = criterion(outputs, labels)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "\n",
    "            \n",
    "            # print statistics\n",
    "            losses.append(loss)\n",
    "            running_loss += loss.item()\n",
    "            if i % 100 == 99:  # print every 2000 mini-batches\n",
    "                print('[%d, %5d] loss: %.10f' %\n",
    "                      (epoch + 1, i + 1, running_loss / 2000))\n",
    "                running_loss = 0.0\n",
    "    plt.plot(losses, label='Training loss')\n",
    "    plt.show()\n",
    "    print('Finished Training')\n",
    "train_net(50)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "FaMAQrp1X1tR",
   "metadata": {
    "id": "FaMAQrp1X1tR"
   },
   "source": [
    "**Saving The Trained Model**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "rd8GTkh-iKEZ",
   "metadata": {
    "id": "rd8GTkh-iKEZ"
   },
   "outputs": [],
   "source": [
    "PATH = './test_data_2.pth'\n",
    "torch.save(net.state_dict(), PATH)\n",
    "\n",
    "# Loading the trained network\n",
    "# net.load_state_dict(torch.load(PATH))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8QAIHMYYE_h",
   "metadata": {
    "id": "d8QAIHMYYE_h"
   },
   "source": [
    "**Testing the Trained Model**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "jWAPVO_-iRnz",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 324
    },
    "executionInfo": {
     "elapsed": 2233,
     "status": "ok",
     "timestamp": 1642862811400,
     "user": {
      "displayName": "Sayandeep Ghosh",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GhWbi6vmkcAJ8Wto5FqFEjJhfKJ15-45rQCkTbN1A=s64",
      "userId": "18045142520943844949"
     },
     "user_tz": -330
    },
    "id": "jWAPVO_-iRnz",
    "outputId": "d413b8e4-d581-407f-ce85-075bde3990ca"
   },
   "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"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GroundTruth:  surprise happy angry sad   neutral fear  happy fear  sad   happy sad   angry happy surprise angry fear  fear  happy happy sad   sad   sad   fear  neutral fear  sad   sad   sad   surprise neutral neutral surprise surprise angry sad   happy sad   fear  happy angry happy angry neutral fear  fear  surprise fear  happy fear  sad   happy sad   happy happy sad   surprise happy fear  angry happy surprise neutral neutral sad   sad   neutral neutral neutral surprise fear  angry surprise neutral neutral happy happy neutral angry fear  angry sad   surprise angry fear  angry surprise neutral happy happy happy fear  disgust fear  neutral angry happy sad   fear  neutral angry\n"
     ]
    }
   ],
   "source": [
    "dataiter = iter(test)\n",
    "images, labels = dataiter.next()\n",
    "\n",
    "# print images\n",
    "imshow(torchvision.utils.make_grid(images))\n",
    "print('GroundTruth: ', ' '.join(f'{classes[labels[j]]:5s}' for j in range(100)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3r-_cir9iWMz",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 1020,
     "status": "ok",
     "timestamp": 1642862816330,
     "user": {
      "displayName": "Sayandeep Ghosh",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GhWbi6vmkcAJ8Wto5FqFEjJhfKJ15-45rQCkTbN1A=s64",
      "userId": "18045142520943844949"
     },
     "user_tz": -330
    },
    "id": "3r-_cir9iWMz",
    "outputId": "3acbf151-1e1c-4380-96e2-53177a0b660b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# net = Net()\n",
    "net=LeNet5_convnet()\n",
    "net.load_state_dict(torch.load(PATH))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "qSTylCgxihZw",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 4004,
     "status": "ok",
     "timestamp": 1642862822590,
     "user": {
      "displayName": "Sayandeep Ghosh",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GhWbi6vmkcAJ8Wto5FqFEjJhfKJ15-45rQCkTbN1A=s64",
      "userId": "18045142520943844949"
     },
     "user_tz": -330
    },
    "id": "qSTylCgxihZw",
    "outputId": "cbb3454c-f0e8-4d0f-f441-481caf5bf94c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicted:  surprise happy sad   sad   sad   neutral happy sad   neutral happy neutral sad   happy neutral happy surprise sad   happy sad   happy angry sad   sad   neutral happy happy happy happy surprise neutral neutral surprise surprise surprise neutral happy neutral fear  happy happy happy sad   surprise happy sad   surprise fear  happy happy surprise happy sad   happy happy sad   surprise happy sad   happy happy neutral sad   neutral neutral neutral neutral sad   sad   angry sad   surprise happy sad   neutral happy happy neutral happy angry happy surprise surprise sad   sad   angry surprise neutral sad   happy happy sad   angry happy sad   neutral happy sad   surprise happy angry\n"
     ]
    }
   ],
   "source": [
    "outputs = net(images)\n",
    "\n",
    "_, predicted = torch.max(outputs, 1)\n",
    "\n",
    "print('Predicted: ', ' '.join(f'{classes[predicted[j]]:5s}'\n",
    "                              for j in range(100)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0wRh6SnLYwho",
   "metadata": {
    "id": "0wRh6SnLYwho"
   },
   "source": [
    "**Overall Accuracy with 50 epochs** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "PgfXqfFRimBP",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 199606,
     "status": "ok",
     "timestamp": 1642863046134,
     "user": {
      "displayName": "Sayandeep Ghosh",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GhWbi6vmkcAJ8Wto5FqFEjJhfKJ15-45rQCkTbN1A=s64",
      "userId": "18045142520943844949"
     },
     "user_tz": -330
    },
    "id": "PgfXqfFRimBP",
    "outputId": "8bb8c274-b36f-496f-b82f-8e8b93c79fe2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of the network on the 10000 test images: 48 %\n"
     ]
    }
   ],
   "source": [
    "correct = 0\n",
    "total = 0\n",
    "# since we're not training, we don't need to calculate the gradients for our outputs\n",
    "with torch.no_grad():\n",
    "    for data in test:\n",
    "        images, labels = data\n",
    "        # images, labels = data[0].to(device), data[1].to(device)\n",
    "        # calculate outputs by running images through the network\n",
    "        outputs = net(images)\n",
    "        # the class with the highest energy is what we choose as prediction\n",
    "        _, predicted = torch.max(outputs.data, 1)\n",
    "        total += labels.size(0)\n",
    "        correct += (predicted == labels).sum().item()\n",
    "\n",
    "print(f'Accuracy of the network on the 10000 test images: {100 * correct // total} %')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "TqzdhlCMY6hi",
   "metadata": {
    "id": "TqzdhlCMY6hi"
   },
   "source": [
    "**Classwise Accuracy** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "Wk7N2iOai0i-",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 197130,
     "status": "ok",
     "timestamp": 1642863256972,
     "user": {
      "displayName": "Sayandeep Ghosh",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GhWbi6vmkcAJ8Wto5FqFEjJhfKJ15-45rQCkTbN1A=s64",
      "userId": "18045142520943844949"
     },
     "user_tz": -330
    },
    "id": "Wk7N2iOai0i-",
    "outputId": "4f0e9f80-f855-428f-cf39-656fb4c0304d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy for class: angry is 30.1 %\n",
      "Accuracy for class: disgust is 13.5 %\n",
      "Accuracy for class: fear  is 15.0 %\n",
      "Accuracy for class: happy is 72.8 %\n",
      "Accuracy for class: neutral is 58.3 %\n",
      "Accuracy for class: sad   is 42.7 %\n",
      "Accuracy for class: surprise is 60.3 %\n"
     ]
    }
   ],
   "source": [
    "correct_pred = {classname: 0 for classname in classes}\n",
    "total_pred = {classname: 0 for classname in classes}\n",
    "\n",
    "# again no gradients needed\n",
    "with torch.no_grad():\n",
    "    for data in test:\n",
    "        images, labels = data\n",
    "        outputs = net(images)\n",
    "        _, predictions = torch.max(outputs, 1)\n",
    "        # collect the correct predictions for each class\n",
    "        for label, prediction in zip(labels, predictions):\n",
    "            if label == prediction:\n",
    "                correct_pred[classes[label]] += 1\n",
    "            total_pred[classes[label]] += 1\n",
    "\n",
    "\n",
    "# print accuracy for each class\n",
    "for classname, correct_count in correct_pred.items():\n",
    "    accuracy = 100 * float(correct_count) / total_pred[classname]\n",
    "    print(f'Accuracy for class: {classname:5s} is {accuracy:.1f} %')"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "Facial_Emotion_Classification_Task.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}