VGG19+SVM.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "qWAKutLrKDtS",
        "3Dv37UXZJwi6",
        "uZS3nSxWh9g4",
        "W99Zqq7clT-D",
        "gKyiBBX923RY",
        "XIpUkD1X3MtN",
        "eBMIcDDr3ng0",
        "S5Bossa0Kcm-",
        "Gm9y6iLzKh7E",
        "wtA9ZtO71lAa",
        "rmCpUfeyLFep"
      ]
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qWAKutLrKDtS"
      },
      "source": [
        "### Connect to Google Drive"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lxF0VRWmI1zZ"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3Dv37UXZJwi6"
      },
      "source": [
        "### Extract dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ijw6GpxGJjal"
      },
      "source": [
        "! tar -zxvf drive/MyDrive/I2ML/dataset.tar.gz"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m9xUEKI_oHPX"
      },
      "source": [
        "#%cd dataset\n",
        "#%cd ..\n",
        "! ls\n",
        "# cd train\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uZS3nSxWh9g4"
      },
      "source": [
        "### Splitting folder for validation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "82R-AJRNGSe5"
      },
      "source": [
        "! mkdir dataset/src"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aAl6vHK8GFJ4"
      },
      "source": [
        "from distutils.dir_util import copy_tree\n",
        "import shutil\n",
        "copy_tree(\"dataset/train/\", \"dataset/src\")\n",
        "\n",
        "shutil.rmtree('dataset/train/')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dI-Y4LjWGYX_"
      },
      "source": [
        "! ls dataset/src/Merging/"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rKDdMzbwiGY3"
      },
      "source": [
        "import os\n",
        "import numpy as np\n",
        "import shutil\n",
        "import random\n",
        "\n",
        "# # Creating Train / Val folders (One time use)\n",
        "root_dir = 'dataset'\n",
        "classes_dir = ['/Barred Spiral','/Edge-on without Bulge','/Unbarred Loose Spiral','/Cigar Shaped Smooth','/In-between Round Smooth','/Unbarred Tight Spiral','/Disturbed','/Merging','/Edge-on with Bulge','/Round Smooth']\n",
        "\n",
        "#val_ratio = 0.15\n",
        "#test_ratio = 0.05\n",
        "for cls in classes_dir:\n",
        "    \n",
        "    os.makedirs(root_dir +'/train' + cls)\n",
        "    os.makedirs(root_dir +'/val' + cls)\n",
        "\n",
        "    # Creating partitions of the data after shuffeling\n",
        "    src = root_dir + \"/src\" + cls # Folder to copy images from\n",
        "\n",
        "    allFileNames = os.listdir(src)\n",
        "    random.shuffle(allFileNames)\n",
        "    print(len(allFileNames))\n",
        "    \n",
        "    \n",
        "    np.random.shuffle(allFileNames)\n",
        "    train_FileNames, val_FileNames = np.split(np.array(allFileNames), [int(len(allFileNames)*0.8)])\n",
        "                                              \n",
        "\n",
        "    \"\"\"\n",
        "    train_FileNames, val_FileNames = torch.utils.data.random_split(allFileNames[i], \n",
        "                                                                  [int(len(allFileNames[i])*0.8), int(len(allFileNames[i])*0.2)], \n",
        "                                                                  generator=torch.Generator().manual_seed(42))\n",
        "    \"\"\"\n",
        "\n",
        "\n",
        "    train_FileNames = [src+'/'+ name for name in train_FileNames.tolist()]\n",
        "    val_FileNames = [src+'/' + name for name in val_FileNames.tolist()]\n",
        "\n",
        "    print('Total images: ', len(allFileNames))\n",
        "    print('Training: ', len(train_FileNames))\n",
        "    print('Validation: ', len(val_FileNames))\n",
        "\n",
        "    # Copy-pasting images\n",
        "    for name in train_FileNames:\n",
        "        shutil.copy(name, root_dir +'/train' + cls)\n",
        "\n",
        "    for name in val_FileNames:\n",
        "        shutil.copy(name, root_dir +'/val' + cls)\n",
        "    \n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FNiBOAD6RTaM"
      },
      "source": [
        "!ls dataset/val/Barred\\ Spiral"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4VDnxJYYBSmh"
      },
      "source": [
        "! mkdir dataset/test/unknown\n",
        "! mv dataset/test/*.png dataset/test/unknown/"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W99Zqq7clT-D"
      },
      "source": [
        "# Various imports"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j8aKGYzA6r5U"
      },
      "source": [
        "import numpy as np # linear algebra\n",
        "import os\n",
        "import torch\n",
        "import tarfile\n",
        "import torchvision\n",
        "import torch.nn as nn\n",
        "from PIL import Image\n",
        "import matplotlib.pyplot as plt\n",
        "import torch.nn.functional as F\n",
        "from torchvision import transforms\n",
        "from torchvision.utils import make_grid\n",
        "from torch.utils.data import random_split\n",
        "from torchvision.transforms import ToTensor\n",
        "from torchvision.datasets import ImageFolder\n",
        "from torch.utils.data import Dataset, DataLoader\n",
        "from torchvision.datasets.utils import download_url\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gKyiBBX923RY"
      },
      "source": [
        "# Dataset, data loader, transformations"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p0P-5dX--O-u"
      },
      "source": [
        "transform_train = transforms.Compose([\n",
        "    \n",
        "    transforms.Resize((224,224)), \n",
        "    transforms.RandomHorizontalFlip(),\n",
        "    transforms.RandomVerticalFlip(),\n",
        "    transforms.RandomRotation(degrees=180),\n",
        "    transforms.ToTensor(),\n",
        "    #transforms.Normalize((.5, .5, .5), (.5, .5, .5))\n",
        "    transforms.Normalize([0.485, 0.456, 0.406],[0.229, 0.224, 0.225])\n",
        "    \n",
        "])\n",
        "\n",
        "#Augmentation is not done for test/validation data.\n",
        "transform_test = transforms.Compose([\n",
        "    \n",
        "    transforms.Resize((224,224)),\n",
        "    transforms.ToTensor(),\n",
        "    #transforms.Normalize((.5, .5, .5), (.5, .5, .5))\n",
        "    transforms.Normalize([0.485, 0.456, 0.406],[0.229, 0.224, 0.225])\n",
        "    \n",
        "])\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8typXenG-Rgl"
      },
      "source": [
        "train_ds = ImageFolder('./dataset/train', transform=transform_train)\n",
        "test_ds = ImageFolder('./dataset/val', transform=transform_test)\n",
        "pred_ds = ImageFolder('./dataset/test', transform=transform_test)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ak6NpxPH-UGh",
        "outputId": "5f400ebc-53aa-4670-ede6-d503c1f6485e"
      },
      "source": [
        "#checking lengths\n",
        "len(train_ds),len(test_ds),len(pred_ds)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(9928, 2487, 5321)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "po4XahDAEHKM",
        "outputId": "efa5be7c-7bd3-4829-a356-0c100742d701"
      },
      "source": [
        "image,label  = train_ds[0]\n",
        "print(image.shape, label)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "torch.Size([3, 224, 224]) 0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cPPsnvgWEvxb"
      },
      "source": [
        "batch_size=32\n",
        "train_dl = DataLoader(train_ds, batch_size, shuffle=True, num_workers=2, pin_memory=True)\n",
        "val_dl = DataLoader(test_ds, batch_size, num_workers=2, pin_memory=True)\n",
        "pred_dl = DataLoader(pred_ds, batch_size, num_workers=2, pin_memory=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XIpUkD1X3MtN"
      },
      "source": [
        "# Visualization of a batch in train set"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 177
        },
        "id": "PtUPjuOqFIF0",
        "outputId": "ed74dddc-4f14-4e4a-bee1-ed39d3727136"
      },
      "source": [
        "for images, _ in train_dl:\n",
        "    print('images.shape:', images.shape)\n",
        "    plt.figure(figsize=(16,8))\n",
        "    plt.axis('off')\n",
        "    plt.imshow(make_grid(images, nrow=16).permute((1, 2, 0)))\n",
        "    break"
      ],
      "execution_count": null,
      "outputs": [
        {
          "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"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "images.shape: torch.Size([32, 3, 224, 224])\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1152x576 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eBMIcDDr3ng0"
      },
      "source": [
        "# Utilities"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "paBRROctF3yx",
        "outputId": "a04c39a4-dad9-4e60-d97d-296573f974da"
      },
      "source": [
        "import pathlib\n",
        "root = pathlib.Path('./dataset/train')\n",
        "classes = sorted([j.name.split('/')[-1] for j in root.iterdir()])\n",
        "classes"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Barred Spiral',\n",
              " 'Cigar Shaped Smooth',\n",
              " 'Disturbed',\n",
              " 'Edge-on with Bulge',\n",
              " 'Edge-on without Bulge',\n",
              " 'In-between Round Smooth',\n",
              " 'Merging',\n",
              " 'Round Smooth',\n",
              " 'Unbarred Loose Spiral',\n",
              " 'Unbarred Tight Spiral']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S5Bossa0Kcm-"
      },
      "source": [
        "# Defintion of accuracy, training step, validation step"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R10wPf38GBQ4"
      },
      "source": [
        "def accuracy(outputs, labels):\n",
        "    _, preds = torch.max(outputs, dim=1)\n",
        "    return torch.tensor(torch.sum(preds == labels).item() / len(preds))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hsCO2guBG5-i"
      },
      "source": [
        "class ImageClassificationBase(nn.Module):\n",
        "    def training_step(self, batch):\n",
        "        images, labels = batch \n",
        "        out = self(images)                  # Generate predictions\n",
        "        loss = F.cross_entropy(out, labels) # Calculate loss\n",
        "        \n",
        "        acc = accuracy(out, labels)\n",
        "        return loss, acc\n",
        "        \n",
        "    \n",
        "    def validation_step(self, batch):\n",
        "        images, labels = batch \n",
        "        out = self(images)                    # Generate predictions\n",
        "        loss = F.cross_entropy(out, labels)   # Calculate loss\n",
        "        acc = accuracy(out, labels)           # Calculate accuracy\n",
        "        return {'val_loss': loss.detach(), 'val_acc': acc}\n",
        "        \n",
        "    def validation_epoch_end(self, outputs):\n",
        "        batch_losses = [x['val_loss'] for x in outputs]\n",
        "        epoch_loss = torch.stack(batch_losses).mean()   # Combine losses\n",
        "        batch_accs = [x['val_acc'] for x in outputs]\n",
        "        epoch_acc = torch.stack(batch_accs).mean()      # Combine accuracies\n",
        "        return {'val_loss': epoch_loss.item(), 'val_acc': epoch_acc.item()}\n",
        "    \n",
        "    def epoch_end(self, epoch, result):\n",
        "        print(\"Epoch [{}], train_loss: {:.4f}, train_acc: {:.4f},  val_loss: {:.4f}, val_acc: {:.4f}\".format(\n",
        "            epoch, result['train_loss'], result['train_acc'], result['val_loss'], result['val_acc']))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZYuRXxuB4WaW"
      },
      "source": [
        "class CnnModelVGG(ImageClassificationBase):\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "        self.network = modelvgg19\n",
        "        \n",
        "    def forward(self, xb):\n",
        "        return self.network(xb)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gm9y6iLzKh7E"
      },
      "source": [
        "# Defining the functions for devices"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Fk0-xUT5eIY3"
      },
      "source": [
        "def get_default_device():\n",
        "    \"\"\"Pick GPU if available, else CPU\"\"\"\n",
        "    if torch.cuda.is_available():\n",
        "        return torch.device('cuda')\n",
        "    else:\n",
        "        return torch.device('cpu')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6HBQYi9JeL4g"
      },
      "source": [
        "def to_device(data, device):\n",
        "    \"\"\"Move tensor(s) to chosen device\"\"\"\n",
        "    if isinstance(data, (list,tuple)):\n",
        "        return [to_device(x, device) for x in data]\n",
        "    return data.to(device, non_blocking=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cChRgfFmeOX4"
      },
      "source": [
        "class DeviceDataLoader():\n",
        "    \"\"\"Wrap a dataloader to move data to a device\"\"\"\n",
        "    def __init__(self, dl, device):\n",
        "        self.dl = dl\n",
        "        self.device = device\n",
        "        \n",
        "    def __iter__(self):\n",
        "        \"\"\"Yield a batch of data after moving it to device\"\"\"\n",
        "        for b in self.dl: \n",
        "            yield to_device(b, self.device)\n",
        "\n",
        "    def __len__(self):\n",
        "        \"\"\"Number of batches\"\"\"\n",
        "        return len(self.dl)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y8yjYm4meSBf",
        "outputId": "7e8bfa5e-8c3a-48a1-b6ef-49a2ad52c0a9"
      },
      "source": [
        "device = get_default_device()\n",
        "device"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "device(type='cuda')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZQ30wZhbecXk"
      },
      "source": [
        "train_dl = DeviceDataLoader(train_dl, device)\n",
        "val_dl = DeviceDataLoader(val_dl, device)\n",
        "pred_dl = DeviceDataLoader(pred_dl, device)\n",
        "#to_device(model, device);"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wtA9ZtO71lAa"
      },
      "source": [
        "# Training phase"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-LNhvnKDdKbm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f5e76259-a5ca-4459-9ccd-818332c13fba"
      },
      "source": [
        "categories = []\n",
        "for d in os.listdir(\"dataset/train\"):\n",
        "    categories.append(d)\n",
        "    \n",
        "n_classes = len(categories)\n",
        "print(f'There are {n_classes} different classes.')\n",
        "\n",
        "categories = sorted(categories)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "There are 10 different classes.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JSL2ySyOLgNs"
      },
      "source": [
        "Defining the last layer of the network"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OuPH99reQXvY"
      },
      "source": [
        "class Identity(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Identity, self).__init__()\n",
        "        \n",
        "    def forward(self, x):\n",
        "        return x"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qgCVFcR3LdXb"
      },
      "source": [
        "Using the premade class for metrics"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3ftwem70OmcR"
      },
      "source": [
        "class ClassificationMetrics:\n",
        "\n",
        "  # Constructor takes the number of classes\n",
        "  def __init__(self, num_classes=10):\n",
        "    self.num_classes = num_classes\n",
        "    # Initialize a confusion matrix\n",
        "    self.C = torch.zeros(num_classes, num_classes) \n",
        "\n",
        "  # Update the confusion matrix with the new scores\n",
        "  def add(self, yp, yt):\n",
        "    # yp: 1D tensor with predictions\n",
        "    # yt: 1D tensor with ground-truth targets\n",
        "    with torch.no_grad(): # We require no computation graph\n",
        "      self.C+=(yt*self.C.shape[1]+yp).bincount(minlength=self.C.numel()).view(self.C.shape).float()\n",
        "\n",
        "  def clear(self):\n",
        "    # We set the confusion matrix to zero\n",
        "    self.C.zero_()\n",
        "\n",
        "  # Computes the global accuracy\n",
        "  def acc(self):\n",
        "    return self.C.diag().sum().item()/self.C.sum()\n",
        "\n",
        "  # Computes the class-averaged accuracy\n",
        "  def mAcc(self):\n",
        "    return (self.C.diag()/self.C.sum(-1)).mean().item()\n",
        "\n",
        "  # Computers the class-averaged Intersection over Union\n",
        "  def mIoU(self):\n",
        "    return (self.C.diag()/(self.C.sum(0)+self.C.sum(1)-self.C.diag())).mean().item()\n",
        "\n",
        "  # Returns the confusion matrix\n",
        "  def confusion_matrix(self):\n",
        "    return self.C"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oAnE0CDzLTrr"
      },
      "source": [
        "Retrieving of the best model and changing the last layer "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7fki4xt8BQ61"
      },
      "source": [
        "bestModel = torch.load('/content/drive/MyDrive/Models/VGG/VGG19best.model')\n",
        "bestModel.classifier = Identity()\n",
        "bestModel.eval()\n",
        "bestModel = to_device(bestModel, device)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LOBLcA56LVV7"
      },
      "source": [
        "Using SVM for training"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZchxPrn_On6h",
        "outputId": "0702b961-03bd-4e8c-87b5-431e345ec438"
      },
      "source": [
        "from sklearn import svm\n",
        "\n",
        "features = []\n",
        "targets=[]\n",
        "\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "\n",
        "with torch.no_grad():\n",
        "  for X,yt in train_dl:\n",
        "    #X, yt = X.to(device), yt.to(device)\n",
        "\n",
        "    ft_single = bestModel(X)\n",
        "\n",
        "    ft_single = ft_single.cpu()\n",
        "    yt = yt.cpu()\n",
        "\n",
        "    features.append(ft_single)\n",
        "    targets.append(yt)\n",
        "\n",
        "features=torch.cat(features,dim=0)\n",
        "targets=torch.cat(targets,dim=0)\n",
        "\n",
        "\n",
        "\n",
        "svm_model=svm.SVC()\n",
        "svm_model.fit(features,targets)\n",
        "\n",
        "# We compute the performance of the trained svm on val data\n",
        "metric_tracker=ClassificationMetrics(num_classes=10)\n",
        "for X,yt in val_dl:\n",
        "  with torch.no_grad():\n",
        "    \n",
        "    feat=bestModel(X)\n",
        "\n",
        "    feat = feat.cpu()\n",
        "\n",
        "    yp = svm_model.predict(feat)\n",
        "\n",
        "    yt = yt.cpu()\n",
        "\n",
        "    metric_tracker.add(yp,yt)\n",
        "\n",
        "print(\"Acc: {} | mAcc: {} | mIoU: {}\".format(metric_tracker.acc(),metric_tracker.mAcc(),metric_tracker.mIoU() ))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Acc: 0.8890228867530823 | mAcc: 0.8697832226753235 | mIoU: 0.7806361317634583\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rmCpUfeyLFep"
      },
      "source": [
        "# Testing phase"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X1D5e4zWLJ32"
      },
      "source": [
        "Here we define the function that make the prediction on the single image"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7U_ivyoec1Bk"
      },
      "source": [
        "def predict_single_testSVM(input, model, svm_model, path, pred_list):\n",
        "    input = input.cuda()\n",
        "    inputs = input.unsqueeze(0)   # unsqueeze the input i.e. add an additonal dimension\n",
        "    \n",
        "    feat = model(inputs)\n",
        "    feat = feat.detach().cpu()\n",
        "\n",
        "    pred = svm_model.predict(feat)\n",
        "    pred = torch.from_numpy(pred)\n",
        "    \n",
        "    number_label = (pred).item()\n",
        "\n",
        "    if number_label == 0:\n",
        "      label = categories[0]\n",
        "    if number_label == 1:\n",
        "      label = categories[1]\n",
        "    if number_label == 2:\n",
        "      label = categories[2]\n",
        "    if number_label == 3:\n",
        "      label = categories[3]\n",
        "    if number_label == 4:\n",
        "      label = categories[4]\n",
        "    if number_label == 5:\n",
        "      label = categories[5]\n",
        "    if number_label == 6:\n",
        "      label = categories[6]\n",
        "    if number_label == 7:\n",
        "      label = categories[7]\n",
        "    if number_label == 8:\n",
        "      label = categories[8]\n",
        "    if number_label == 9:\n",
        "      label = categories[9]\n",
        "    \n",
        "    #print(path,\",\",label)\n",
        "    pred_str = \"\"\n",
        "    pred_str = pred_str + path + \",\" + label\n",
        "\n",
        "    pred_dict = {}\n",
        "    pred_dict['pred_str'] = pred_str\n",
        "    pred_dict['num'] = int(path)\n",
        "    \n",
        "    #print(pred_dict)\n",
        "\n",
        "    pred_list.append(pred_dict)\n",
        "    "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1gyEBWp0LN2v"
      },
      "source": [
        "Here we predict the label of each image in test set and write in on a CSV file"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w20sPYHSdYle"
      },
      "source": [
        "from torchvision import datasets\n",
        "class ImageFolderWithPaths(datasets.ImageFolder):\n",
        "    def __getitem__(self, index):\n",
        "        return super(ImageFolderWithPaths, self).__getitem__(index) + (self.imgs[index][0],)\n",
        "\n",
        "\n",
        "# instantiate the dataset and dataloader\n",
        "data_dir = \"dataset/test\"\n",
        "dataset = ImageFolderWithPaths(root=data_dir, transform=transform_test)\n",
        "dataloader = DataLoader(dataset)\n",
        "\n",
        "pred_list = []\n",
        "\n",
        "for inputs, labels, paths in dataloader:\n",
        "   \n",
        "\n",
        "    sliced = paths[0]\n",
        "    sliced = sliced.replace('.png','')\n",
        "    sliced = sliced.replace('dataset/test/unknown/','')\n",
        "    \n",
        "    \n",
        "    \n",
        "\n",
        "    predict_single_testSVM(inputs[0],bestModel, svm_model, sliced, pred_list)\n",
        "\n",
        "\n",
        "    \n",
        "pred_list = sorted(pred_list, key=lambda k: int(k['num'])) \n",
        "\n",
        "text_file = open(\"dataset/output.csv\", \"a\")\n",
        "\n",
        "\n",
        "for x in pred_list:\n",
        "  #print (x['pred_str'])\n",
        "  text_file.write(x['pred_str'])\n",
        "  text_file.write(\"\\n\")\n",
        "\n",
        "text_file.close()\n"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}