18.Pytorch Class Accuracy on Imbalance Dataset with Caltech256.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Class Accuracies for Imbalanced Data in Deep Learning Image Recognition\n",
    "- Class Imbalance is major issue when we train a neural network, which happens because of different class have diffrent frequency distribution."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dataset : [Catlech256](http://www.vision.caltech.edu/Image_Datasets/Caltech256/)\n",
    "- Total Images: **30698**\n",
    "- Total Classes : **257**\n",
    "- Actually how imbalanced is the Caltech256 vision dataset? The following bar plot will give a better idea of the image number distributions.\n",
    "![](https://debuggercafe.com/wp-content/uploads/2020/03/distribution.gif)\n",
    "- [Source](http://www.vision.caltech.edu/Image_Datasets/Caltech256/intro/)\n",
    "- Most of the categories have images between 80 to 150 and Some Category contains more than 200 to 300 images and clutter class substracted because of the highest 827 images contained.\n",
    "![](https://debuggercafe.com/wp-content/uploads/2020/03/class_dist.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **1.Load Libraries**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "try:\n",
    "    from imutils import paths\n",
    "    import pretrainedmodels\n",
    "except:\n",
    "    os.system(\"pip install imutils pretrainedmodels\")\n",
    "    \n",
    "import matplotlib.pyplot as plt\n",
    "import joblib\n",
    "import cv2\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import time\n",
    "import numpy as np\n",
    "plt.style.use('ggplot')\n",
    "\n",
    "from sklearn.preprocessing import LabelBinarizer\n",
    "from sklearn.model_selection import train_test_split\n",
    "from torchvision.transforms import transforms\n",
    "from torch.utils.data import DataLoader, Dataset\n",
    "from tqdm import tqdm\n",
    "import pretrainedmodels\n",
    "import random\n",
    "\n",
    "'''\n",
    "seed Everything\n",
    "'''\n",
    "def seed_everything(seed=1234):\n",
    "    random.seed(seed)\n",
    "    np.random.seed(seed)\n",
    "    torch.manual_seed(seed)\n",
    "    torch.cuda.manual_seed_all(seed)\n",
    "    torch.cuda.manual_seed_all(seed)\n",
    "    torch.backends.cudnn.benchmark = True # as we will resize the images\n",
    "    \n",
    "seed = 42\n",
    "seed_everything(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above code block, some of the important modules are:\n",
    "\n",
    "* `torch.nn` will help us access the neural network layers in the PyTorch library.\n",
    "* `torch.optim` to access all the optimizer functions in PyTorch.\n",
    "* `pretrainedmodels` to access all the pre-trained models like `ResNet34` and many more. We installed this library in one of the previous sections.\n",
    "* Using `torchvision.transforms` we can apply `transforms` to our image like `normalization` and `resizing`.\n",
    "* `DataLoader` and `Dataset` from the `torchvision.transforms` will help us to create our own custom image dataset module and iterable data loaders.\n",
    "* `cv2` to read images in the dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **2.Load the Devices**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "epochs = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **3.Define the Transforms**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_transform = transforms.Compose(\n",
    "    [\n",
    "        transforms.ToPILImage(),\n",
    "        transforms.Resize((224, 224)),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize(mean = [ 0.485, 0.456, 0.406 ],\n",
    "                             std = [0.229, 0.224, 0.225])\n",
    "    ]\n",
    ")\n",
    "val_transform = transforms.Compose(\n",
    "    [\n",
    "        transforms.ToPILImage(),\n",
    "        transforms.Resize((224, 224)),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize(mean = [ 0.485, 0.456, 0.406 ],std=[0.229, 0.224, 0.225])\n",
    "    ]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **4.Images and Labels**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 9144/9144 [00:10<00:00, 872.85it/s] \n"
     ]
    }
   ],
   "source": [
    "image_paths = list(paths.list_images('./101_ObjectCategories'))\n",
    "\n",
    "data = []\n",
    "labels = []\n",
    "for image_path in tqdm(image_paths, total=len(image_paths)):\n",
    "    label = image_path.split(os.path.sep)[-2]\n",
    "    if label == 'clutter':\n",
    "        continue\n",
    "    image = cv2.imread(image_path)\n",
    "    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
    "    image = cv2.resize(image, (128, 128))\n",
    "    \n",
    "    data.append(image)\n",
    "    labels.append(label)\n",
    "    \n",
    "data = np.array(data)\n",
    "labels  = np.array(labels)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **5.Label Encoder**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Number of Classes: 102\n"
     ]
    }
   ],
   "source": [
    "lb = LabelBinarizer()\n",
    "labels = lb.fit_transform(labels)\n",
    "print(f\"Total Number of Classes: {len(lb.classes_)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **6.Preparing train, test and Validation Dataset**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_Train: (5486, 128, 128, 3) X_Val: (1829, 128, 128, 3) X_Test: (1829, 128, 128, 3)\n",
      "Y_Train: (5486, 102) y_Val: (1829, 102) y_Test: (1829, 102)\n"
     ]
    }
   ],
   "source": [
    "(X, X_val, y, y_val) = train_test_split(data, labels, test_size=0.2, stratify=labels, random_state=seed)\n",
    "(X_train, X_test, y_train, y_test) = train_test_split(X, y, test_size=0.25, random_state=seed)\n",
    "print(f\"X_Train: {X_train.shape} X_Val: {X_val.shape} X_Test: {X_test.shape}\")\n",
    "print(f\"Y_Train: {y_train.shape} y_Val: {y_val.shape} y_Test: {y_test.shape}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **7.Prepare the Image Dataset using Train Loader and Test Loader**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ImageDataset(Dataset):\n",
    "    def __init__(self, images, labels, transform=None):\n",
    "        self.X = images\n",
    "        self.y = labels\n",
    "        self.transforms = transform\n",
    "        \n",
    "    def __len__(self):\n",
    "        return len(self.X)\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        data = self.X[index]\n",
    "        \n",
    "        if self.transforms:\n",
    "            data = self.transforms(data)\n",
    "            \n",
    "        if self.y is not None:\n",
    "            label = self.y[index]\n",
    "            return data, label\n",
    "        else:\n",
    "            return data\n",
    "        \n",
    "train_Data = ImageDataset(X_train, y_train, transform=train_transform)\n",
    "val_Data = ImageDataset(X_val, y_val, transform=val_transform)\n",
    "test_Data = ImageDataset(X_test, y_test, transform=val_transform)\n",
    "\n",
    "# Data Loader (Input Pipeline)\n",
    "trainloader = DataLoader(dataset=train_Data, batch_size=32, shuffle=True)\n",
    "valloader = DataLoader(dataset=val_Data, batch_size=32, shuffle=True)\n",
    "testloader = DataLoader(dataset=test_Data, batch_size=32, shuffle=True)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **8.Design Neural Network**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ResNet50(nn.Module):\n",
    "    def __init__(self, pretrained):\n",
    "        super().__init__()\n",
    "        if pretrained is True:\n",
    "            self.model = pretrainedmodels.__dict__['resnet50'](pretrained='imagenet')\n",
    "        else:\n",
    "            self.model = pretrainedmodels.__dict__['resnet50'](pretrained=None)\n",
    "        self.l0 = nn.Linear(2048, len(lb.classes_))\n",
    "        self.dropout = nn.Dropout2d(0.4)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        batch, channels, height, width = x.shape\n",
    "        x = self.model.features(x)\n",
    "        x = F.adaptive_avg_pool2d(x, 1).reshape(batch, -1)\n",
    "        x = self.dropout(x)\n",
    "        l0 = self.l0(x)\n",
    "        return l0\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ResNet50(\n",
      "  (model): ResNet(\n",
      "    (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
      "    (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (relu): ReLU(inplace=True)\n",
      "    (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
      "    (layer1): Sequential(\n",
      "      (0): Bottleneck(\n",
      "        (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU(inplace=True)\n",
      "        (downsample): Sequential(\n",
      "          (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        )\n",
      "      )\n",
      "      (1): Bottleneck(\n",
      "        (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "      (2): Bottleneck(\n",
      "        (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (layer2): Sequential(\n",
      "      (0): Bottleneck(\n",
      "        (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
      "        (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU(inplace=True)\n",
      "        (downsample): Sequential(\n",
      "          (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
      "          (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        )\n",
      "      )\n",
      "      (1): Bottleneck(\n",
      "        (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "      (2): Bottleneck(\n",
      "        (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "      (3): Bottleneck(\n",
      "        (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (layer3): Sequential(\n",
      "      (0): Bottleneck(\n",
      "        (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
      "        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU(inplace=True)\n",
      "        (downsample): Sequential(\n",
      "          (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
      "          (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        )\n",
      "      )\n",
      "      (1): Bottleneck(\n",
      "        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "      (2): Bottleneck(\n",
      "        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "      (3): Bottleneck(\n",
      "        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "      (4): Bottleneck(\n",
      "        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "      (5): Bottleneck(\n",
      "        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (layer4): Sequential(\n",
      "      (0): Bottleneck(\n",
      "        (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
      "        (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU(inplace=True)\n",
      "        (downsample): Sequential(\n",
      "          (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
      "          (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        )\n",
      "      )\n",
      "      (1): Bottleneck(\n",
      "        (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "      (2): Bottleneck(\n",
      "        (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "        (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "        (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (relu): ReLU(inplace=True)\n",
      "      )\n",
      "    )\n",
      "    (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n",
      "    (fc): None\n",
      "    (last_linear): Linear(in_features=2048, out_features=1000, bias=True)\n",
      "  )\n",
      "  (l0): Linear(in_features=2048, out_features=102, bias=True)\n",
      "  (dropout): Dropout2d(p=0.4, inplace=False)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "model = ResNet50(pretrained=True).to(device)\n",
    "print(model)\n",
    "\n",
    "# optimizer\n",
    "optimizer = optim.Adam(model.parameters(), lr=1e-4)\n",
    "# loss function\n",
    "criterion = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **9.Print Model Summary**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=================================================================\n",
      "Layer (type:depth-idx)                   Param #\n",
      "=================================================================\n",
      "├─ResNet: 1-1                            --\n",
      "|    └─Conv2d: 2-1                       9,408\n",
      "|    └─BatchNorm2d: 2-2                  128\n",
      "|    └─ReLU: 2-3                         --\n",
      "|    └─MaxPool2d: 2-4                    --\n",
      "|    └─Sequential: 2-5                   --\n",
      "|    |    └─Bottleneck: 3-1              75,008\n",
      "|    |    └─Bottleneck: 3-2              70,400\n",
      "|    |    └─Bottleneck: 3-3              70,400\n",
      "|    └─Sequential: 2-6                   --\n",
      "|    |    └─Bottleneck: 3-4              379,392\n",
      "|    |    └─Bottleneck: 3-5              280,064\n",
      "|    |    └─Bottleneck: 3-6              280,064\n",
      "|    |    └─Bottleneck: 3-7              280,064\n",
      "|    └─Sequential: 2-7                   --\n",
      "|    |    └─Bottleneck: 3-8              1,512,448\n",
      "|    |    └─Bottleneck: 3-9              1,117,184\n",
      "|    |    └─Bottleneck: 3-10             1,117,184\n",
      "|    |    └─Bottleneck: 3-11             1,117,184\n",
      "|    |    └─Bottleneck: 3-12             1,117,184\n",
      "|    |    └─Bottleneck: 3-13             1,117,184\n",
      "|    └─Sequential: 2-8                   --\n",
      "|    |    └─Bottleneck: 3-14             6,039,552\n",
      "|    |    └─Bottleneck: 3-15             4,462,592\n",
      "|    |    └─Bottleneck: 3-16             4,462,592\n",
      "|    └─AdaptiveAvgPool2d: 2-9            --\n",
      "|    └─Linear: 2-10                      2,049,000\n",
      "├─Linear: 1-2                            208,998\n",
      "├─Dropout2d: 1-3                         --\n",
      "=================================================================\n",
      "Total params: 25,766,030\n",
      "Trainable params: 25,766,030\n",
      "Non-trainable params: 0\n",
      "=================================================================\n",
      "=================================================================\n",
      "Layer (type:depth-idx)                   Param #\n",
      "=================================================================\n",
      "├─ResNet: 1-1                            --\n",
      "|    └─Conv2d: 2-1                       9,408\n",
      "|    └─BatchNorm2d: 2-2                  128\n",
      "|    └─ReLU: 2-3                         --\n",
      "|    └─MaxPool2d: 2-4                    --\n",
      "|    └─Sequential: 2-5                   --\n",
      "|    |    └─Bottleneck: 3-1              75,008\n",
      "|    |    └─Bottleneck: 3-2              70,400\n",
      "|    |    └─Bottleneck: 3-3              70,400\n",
      "|    └─Sequential: 2-6                   --\n",
      "|    |    └─Bottleneck: 3-4              379,392\n",
      "|    |    └─Bottleneck: 3-5              280,064\n",
      "|    |    └─Bottleneck: 3-6              280,064\n",
      "|    |    └─Bottleneck: 3-7              280,064\n",
      "|    └─Sequential: 2-7                   --\n",
      "|    |    └─Bottleneck: 3-8              1,512,448\n",
      "|    |    └─Bottleneck: 3-9              1,117,184\n",
      "|    |    └─Bottleneck: 3-10             1,117,184\n",
      "|    |    └─Bottleneck: 3-11             1,117,184\n",
      "|    |    └─Bottleneck: 3-12             1,117,184\n",
      "|    |    └─Bottleneck: 3-13             1,117,184\n",
      "|    └─Sequential: 2-8                   --\n",
      "|    |    └─Bottleneck: 3-14             6,039,552\n",
      "|    |    └─Bottleneck: 3-15             4,462,592\n",
      "|    |    └─Bottleneck: 3-16             4,462,592\n",
      "|    └─AdaptiveAvgPool2d: 2-9            --\n",
      "|    └─Linear: 2-10                      2,049,000\n",
      "├─Linear: 1-2                            208,998\n",
      "├─Dropout2d: 1-3                         --\n",
      "=================================================================\n",
      "Total params: 25,766,030\n",
      "Trainable params: 25,766,030\n",
      "Non-trainable params: 0\n",
      "=================================================================\n"
     ]
    }
   ],
   "source": [
    "from torchsummary import summary\n",
    "print(summary(model, input_size=(3, 224, 224)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **10.Train Validation and Test Function**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# training function\n",
    "def fit(model, dataloader):\n",
    "    print('Training')\n",
    "    model.train()\n",
    "    running_loss = 0.0\n",
    "    running_correct = 0\n",
    "    for i, data in tqdm(enumerate(dataloader), total=int(len(train_Data)/dataloader.batch_size)):\n",
    "        data, target = data[0].to(device), data[1].to(device)\n",
    "        optimizer.zero_grad()\n",
    "        outputs = model(data)\n",
    "        loss = criterion(outputs, torch.max(target, 1)[1])\n",
    "        running_loss += loss.item()\n",
    "        _, preds = torch.max(outputs.data, 1)\n",
    "        running_correct += (preds == torch.max(target, 1)[1]).sum().item()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "    loss = running_loss/len(dataloader.dataset)\n",
    "    accuracy = 100. * running_correct/len(dataloader.dataset)\n",
    "    \n",
    "    print(f\"Train Loss: {loss:.4f}, Train Acc: {accuracy:.2f}\")\n",
    "    \n",
    "    return loss, accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "#validation function\n",
    "def validate(model, dataloader):\n",
    "    print('Validating')\n",
    "    model.eval()\n",
    "    running_loss = 0.0\n",
    "    running_correct = 0\n",
    "    with torch.no_grad():\n",
    "        for i, data in tqdm(enumerate(dataloader), total=int(len(val_Data)/dataloader.batch_size)):\n",
    "            data, target = data[0].to(device), data[1].to(device)\n",
    "            outputs = model(data)\n",
    "            loss = criterion(outputs, torch.max(target, 1)[1])\n",
    "            \n",
    "            running_loss += loss.item()\n",
    "            _, preds = torch.max(outputs.data, 1)\n",
    "            running_correct += (preds == torch.max(target, 1)[1]).sum().item()\n",
    "        \n",
    "        loss = running_loss/len(dataloader.dataset)\n",
    "        accuracy = 100. * running_correct/len(dataloader.dataset)\n",
    "        print(f'Val Loss: {loss:.4f}, Val Acc: {accuracy:.2f}')\n",
    "        \n",
    "        return loss, accuracy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* In the functions, `validate()`, and `fit()`, we calculate the batch-wise loss and accuracy values. We call those variables `running_loss`, and `running_correct`.\n",
    "* At the end of both the functions, we return the `loss` and `accuracy` for that specific epoch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def class_acc_test(model, testloader):\n",
    "    class_correct = list(0. for i in range(len(lb.classes_)))\n",
    "    class_total = list(0. for i in range(len(lb.classes_)))\n",
    "    with torch.no_grad():\n",
    "        for data in testloader:\n",
    "            inputs, target = data[0].to(device), data[1].to(device)\n",
    "            outputs = model(inputs)\n",
    "            _, predicted = torch.max(outputs.data, 1)\n",
    "            correct = (predicted == torch.max(target, 1)[1])\n",
    "            for i in range(len(predicted)):\n",
    "                label = torch.max(target, 1)[1][i]\n",
    "                class_correct[label] += correct[i].item()\n",
    "                class_total[label] += 1\n",
    "                \n",
    "    for i in range(len(lb.classes_)):\n",
    "        print(f\"Accuracy of {lb.classes_[i]} : {100 * class_correct[i] / class_total[i]:.2f}\")    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **11.Executing Training and validation Function**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 of 10\n",
      "--------------------\n",
      "Training\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "172it [00:52,  3.30it/s]                         \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Loss: 0.0009, Train Acc: 99.58\n",
      "Validating\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "58it [00:07,  7.52it/s]                        \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Val Loss: 0.0062, Val Acc: 95.24\n",
      "Epoch 2 of 10\n",
      "--------------------\n",
      "Training\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "172it [00:55,  3.10it/s]                         \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Loss: 0.0007, Train Acc: 99.69\n",
      "Validating\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "58it [00:08,  7.21it/s]                        \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Val Loss: 0.0070, Val Acc: 94.31\n",
      "Epoch 3 of 10\n",
      "--------------------\n",
      "Training\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "172it [00:49,  3.51it/s]                         \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Loss: 0.0008, Train Acc: 99.60\n",
      "Validating\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "58it [00:07,  7.78it/s]                        \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Val Loss: 0.0079, Val Acc: 93.88\n",
      "Epoch 4 of 10\n",
      "--------------------\n",
      "Training\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "172it [00:49,  3.46it/s]                         \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Loss: 0.0021, Train Acc: 98.52\n",
      "Validating\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "58it [00:07,  7.46it/s]                        \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Val Loss: 0.0148, Val Acc: 89.12\n",
      "Epoch 5 of 10\n",
      "--------------------\n",
      "Training\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "172it [00:51,  3.35it/s]                         \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Loss: 0.0028, Train Acc: 98.27\n",
      "Validating\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "58it [00:08,  6.71it/s]                        \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Val Loss: 0.0124, Val Acc: 89.39\n",
      "Epoch 6 of 10\n",
      "--------------------\n",
      "Training\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "172it [00:52,  3.29it/s]                         \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Loss: 0.0015, Train Acc: 99.14\n",
      "Validating\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "58it [00:07,  7.29it/s]                        \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Val Loss: 0.0092, Val Acc: 92.40\n",
      "Epoch 7 of 10\n",
      "--------------------\n",
      "Training\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "172it [00:51,  3.35it/s]                         \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Loss: 0.0010, Train Acc: 99.40\n",
      "Validating\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "58it [00:07,  7.33it/s]                        \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Val Loss: 0.0102, Val Acc: 91.91\n",
      "Epoch 8 of 10\n",
      "--------------------\n",
      "Training\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "172it [00:51,  3.37it/s]                         \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Loss: 0.0012, Train Acc: 99.31\n",
      "Validating\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "58it [00:07,  7.46it/s]                        \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Val Loss: 0.0139, Val Acc: 90.21\n",
      "Epoch 9 of 10\n",
      "--------------------\n",
      "Training\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "172it [00:51,  3.33it/s]                         \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Loss: 0.0013, Train Acc: 99.03\n",
      "Validating\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "58it [00:07,  8.03it/s]                        \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Val Loss: 0.0113, Val Acc: 90.54\n",
      "Epoch 10 of 10\n",
      "--------------------\n",
      "Training\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "172it [00:50,  3.40it/s]                         \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Loss: 0.0014, Train Acc: 99.14\n",
      "Validating\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "58it [00:06,  8.49it/s]                        "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Val Loss: 0.0093, Val Acc: 92.45\n",
      "9.870497596263885 minutes\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "train_loss , train_accuracy = [], []\n",
    "val_loss , val_accuracy = [], []\n",
    "start = time.time()\n",
    "for epoch in range(epochs):\n",
    "    print(f\"Epoch {epoch+1} of {epochs}\");print('-'*20)\n",
    "    train_epoch_loss, train_epoch_accuracy = fit(model, trainloader)\n",
    "    val_epoch_loss, val_epoch_accuracy = validate(model, valloader)\n",
    "    train_loss.append(train_epoch_loss)\n",
    "    train_accuracy.append(train_epoch_accuracy)\n",
    "    val_loss.append(val_epoch_loss)\n",
    "    val_accuracy.append(val_epoch_accuracy)\n",
    "end = time.time()\n",
    "print((end-start)/60, 'minutes')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **12.Save Model**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.makedirs(\"model\", exist_ok=True)\n",
    "torch.save(model.state_dict(), f\"model/resnet50_epochs{epochs}.pth\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# accuracy plots\n",
    "plt.figure(figsize=(10, 7))\n",
    "plt.plot(train_accuracy, color='green', label='train accuracy')\n",
    "plt.plot(val_accuracy, color='blue', label='validataion accuracy')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.legend()\n",
    "# plt.savefig('../outputs/accuracy.png')\n",
    "plt.show()\n",
    "# loss plots\n",
    "plt.figure(figsize=(10, 7))\n",
    "plt.plot(train_loss, color='orange', label='train loss')\n",
    "plt.plot(val_loss, color='red', label='validataion loss')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Loss')\n",
    "plt.legend()\n",
    "# plt.savefig('../outputs/loss.png')\n",
    "plt.show()\n",
    "# pickling the accuracy and loss values\n",
    "# joblib.dump(train_accuracy, '../outputs/train_accuracy.pkl')\n",
    "# joblib.dump(train_loss, '../outputs/train_loss.pkl')\n",
    "# joblib.dump(val_accuracy, '../outputs/val_accuracy.pkl')\n",
    "# joblib.dump(val_loss, '../outputs/val_loss.pkl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **13.Class wise Accuracy**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of BACKGROUND_Google : 70.21\n",
      "Accuracy of Faces : 100.00\n",
      "Accuracy of Faces_easy : 98.88\n",
      "Accuracy of Leopards : 100.00\n",
      "Accuracy of Motorbikes : 100.00\n",
      "Accuracy of accordion : 100.00\n",
      "Accuracy of airplanes : 99.34\n",
      "Accuracy of anchor : 83.33\n",
      "Accuracy of ant : 77.78\n",
      "Accuracy of barrel : 100.00\n",
      "Accuracy of bass : 75.00\n",
      "Accuracy of beaver : 100.00\n",
      "Accuracy of binocular : 100.00\n",
      "Accuracy of bonsai : 100.00\n",
      "Accuracy of brain : 100.00\n",
      "Accuracy of brontosaurus : 77.78\n",
      "Accuracy of buddha : 100.00\n",
      "Accuracy of butterfly : 90.00\n",
      "Accuracy of camera : 81.82\n",
      "Accuracy of cannon : 75.00\n",
      "Accuracy of car_side : 100.00\n",
      "Accuracy of ceiling_fan : 50.00\n",
      "Accuracy of cellphone : 100.00\n",
      "Accuracy of chair : 80.00\n",
      "Accuracy of chandelier : 73.08\n",
      "Accuracy of cougar_body : 100.00\n",
      "Accuracy of cougar_face : 100.00\n",
      "Accuracy of crab : 61.54\n",
      "Accuracy of crayfish : 62.50\n",
      "Accuracy of crocodile : 78.57\n",
      "Accuracy of crocodile_head : 77.78\n",
      "Accuracy of cup : 100.00\n",
      "Accuracy of dalmatian : 100.00\n",
      "Accuracy of dollar_bill : 100.00\n",
      "Accuracy of dolphin : 100.00\n",
      "Accuracy of dragonfly : 90.91\n",
      "Accuracy of electric_guitar : 85.71\n",
      "Accuracy of elephant : 100.00\n",
      "Accuracy of emu : 71.43\n",
      "Accuracy of euphonium : 93.33\n",
      "Accuracy of ewer : 100.00\n",
      "Accuracy of ferry : 100.00\n",
      "Accuracy of flamingo : 94.12\n",
      "Accuracy of flamingo_head : 100.00\n",
      "Accuracy of garfield : 100.00\n",
      "Accuracy of gerenuk : 100.00\n",
      "Accuracy of gramophone : 92.86\n",
      "Accuracy of grand_piano : 100.00\n",
      "Accuracy of hawksbill : 100.00\n",
      "Accuracy of headphone : 100.00\n",
      "Accuracy of hedgehog : 100.00\n",
      "Accuracy of helicopter : 100.00\n",
      "Accuracy of ibis : 100.00\n",
      "Accuracy of inline_skate : 100.00\n",
      "Accuracy of joshua_tree : 87.50\n",
      "Accuracy of kangaroo : 96.00\n",
      "Accuracy of ketch : 78.26\n",
      "Accuracy of lamp : 80.00\n",
      "Accuracy of laptop : 100.00\n",
      "Accuracy of llama : 100.00\n",
      "Accuracy of lobster : 70.00\n",
      "Accuracy of lotus : 88.89\n",
      "Accuracy of mandolin : 100.00\n",
      "Accuracy of mayfly : 83.33\n",
      "Accuracy of menorah : 85.71\n",
      "Accuracy of metronome : 100.00\n",
      "Accuracy of minaret : 100.00\n",
      "Accuracy of nautilus : 100.00\n",
      "Accuracy of octopus : 66.67\n",
      "Accuracy of okapi : 100.00\n",
      "Accuracy of pagoda : 100.00\n",
      "Accuracy of panda : 60.00\n",
      "Accuracy of pigeon : 90.00\n",
      "Accuracy of pizza : 90.91\n",
      "Accuracy of platypus : 60.00\n",
      "Accuracy of pyramid : 100.00\n",
      "Accuracy of revolver : 92.31\n",
      "Accuracy of rhino : 100.00\n",
      "Accuracy of rooster : 100.00\n",
      "Accuracy of saxophone : 85.71\n",
      "Accuracy of schooner : 93.75\n",
      "Accuracy of scissors : 75.00\n",
      "Accuracy of scorpion : 100.00\n",
      "Accuracy of sea_horse : 85.71\n",
      "Accuracy of snoopy : 100.00\n",
      "Accuracy of soccer_ball : 100.00\n",
      "Accuracy of stapler : 100.00\n",
      "Accuracy of starfish : 100.00\n",
      "Accuracy of stegosaurus : 100.00\n",
      "Accuracy of stop_sign : 100.00\n",
      "Accuracy of strawberry : 100.00\n",
      "Accuracy of sunflower : 100.00\n",
      "Accuracy of tick : 100.00\n",
      "Accuracy of trilobite : 100.00\n",
      "Accuracy of umbrella : 89.47\n",
      "Accuracy of watch : 100.00\n",
      "Accuracy of water_lilly : 20.00\n",
      "Accuracy of wheelchair : 85.71\n",
      "Accuracy of wild_cat : 90.00\n",
      "Accuracy of windsor_chair : 100.00\n",
      "Accuracy of wrench : 80.00\n",
      "Accuracy of yin_yang : 100.00\n"
     ]
    }
   ],
   "source": [
    "# test the model for per-class accuracy\n",
    "class_acc_test(model, testloader)"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "884a8f81666a19c0851426c83cd6eaa7b212468ad852fb3caa21591c98d4369f"
  },
  "kernelspec": {
   "display_name": "Python 3.8.0 64-bit ('pytorch19': conda)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.0"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}