5-feature_compression_using_PCA.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "feature_compression_using_PCA.ipynb",
      "provenance": [],
      "mount_file_id": "16m6d4k8yggJb8hrdEMThHrGv3Tqxr40c",
      "authorship_tag": "ABX9TyNAlP4aOfinuLhLuP4CrAoI",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/AbdullahMakhdoom/Image-Search-Engine/blob/main/feature_compression_using_PCA.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y_-Zb1CfjO7h"
      },
      "source": [
        "**Objective** : In this notebook, we will reduce the size of feature vectors for Caltech101 dataset, generated from ResNet-50, using PCA (stands for Principle Component Analysis).\n",
        "\n",
        "PCA is a statistical procedure that is considered one of the go-to techniques for dimensionality reduction. PCA does not eliminate features that are redundant enough to be removed, rather it generates a new set of features that are linear combinatino of the input features. These linear features  are orthogonal to each other, and are called as principal components.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C0g1j43-jOew"
      },
      "source": [
        "# import necessary packages\n",
        "import numpy as np\n",
        "import pickle\n",
        "from tqdm import tqdm, tqdm_notebook\n",
        "import random\n",
        "import time\n",
        "from sklearn.manifold import TSNE\n",
        "from sklearn.decomposition import PCA\n",
        "import PIL\n",
        "from PIL import Image\n",
        "from sklearn.neighbors import NearestNeighbors\n",
        "import random\n",
        "import glob\n",
        "\n",
        "import matplotlib\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.image as mpimg\n",
        "matplotlib.rcParams['savefig.dpi'] = 160\n",
        "matplotlib.rcParams['figure.dpi'] = 160\n",
        "%matplotlib notebook\n"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "np5FnRFnzpKl"
      },
      "source": [
        "Mount the Google Drive and load the features, class_ids and filenames for Caltech101 dataset."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0OUvwZazzob8"
      },
      "source": [
        "feature_list = pickle.load(open('/content/drive/MyDrive/Caltech101-features/features-caltech101-resnet.pickle', 'rb'))\n",
        "filenames  = pickle.load(open('/content/drive/MyDrive/Caltech101-features/filenames-caltech101.pickle',\n",
        "                                'rb'))\n",
        "class_ids = pickle.load(open('/content/drive/MyDrive/Caltech101-features/class_ids-caltech101.pickle', 'rb'))\n"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ak8liXQWY2kP"
      },
      "source": [
        "num_features_per_image = len(feature_list[0])"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mo8Tt4Ve0dqn"
      },
      "source": [
        "\n",
        "# Helper function to get the classname\n",
        "def classname(str):\n",
        "    return str.split('/')[-2]\n",
        "\n",
        "\n",
        "# Helper function to get the classname and filename\n",
        "def classname_filename(str):\n",
        "    return str.split('/')[-2] + '/' + str.split('/')[-1]\n",
        "\n",
        "\n",
        "# Helper function that calculates accuracy using the nearest neighbors brute force algorithm\n",
        "def calculate_accuracy(feature_list):\n",
        "    num_nearest_neighbors = 5\n",
        "    correct_prediction = 0\n",
        "    incorrect_prediction = 0\n",
        "    neighbors = NearestNeighbors(n_neighbors=num_nearest_neighbors,\n",
        "                                 algorithm='brute',\n",
        "                                 metric='euclidean').fit(feature_list)\n",
        "    start = time.time()\n",
        "    for i in range(len(feature_list)):\n",
        "        distances, indices = neighbors.kneighbors([feature_list[i]])\n",
        "        for j in range(1, num_nearest_neighbors):\n",
        "            if (classname(filenames[i]) == classname(\n",
        "                    filenames[indices[0][j]])):\n",
        "                correct_prediction += 1\n",
        "            else:\n",
        "                incorrect_prediction += 1\n",
        "    end = time.time()\n",
        "    accuracy = round(\n",
        "        100.0 * correct_prediction /\n",
        "        (1.0 * correct_prediction + incorrect_prediction), 2), end - start\n",
        "    return accuracy"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ucU5ECZx0ja0",
        "outputId": "a29bc194-922b-4cc4-c765-a7ec67d65ef2"
      },
      "source": [
        "\n",
        "print(\"Accuracy on original feature set : \",\n",
        "      calculate_accuracy(feature_list[:]))"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy on original feature set :  (88.36, 580.3341600894928)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hjxoBCZY0lNN",
        "outputId": "c987cac3-9aed-4c14-8917-7fada2c810e8"
      },
      "source": [
        "pca_dimensions = [1, 2, 3, 4, 5, 10, 20, 50, 75, 100, 150, 200]\n",
        "pca_accuracy = []\n",
        "pca_time = []\n",
        "\n",
        "for dimensions in pca_dimensions:\n",
        "  pca = PCA(n_components=dimensions)\n",
        "  pca.fit(feature_list)\n",
        "  feature_list_compressed = pca.transform(feature_list[:])\n",
        "  accuracy, t = calculate_accuracy(feature_list_compressed[:])\n",
        "  pca_time.append(t)\n",
        "  pca_accuracy.append(accuracy)\n",
        "  print(\"For PCA Dimensions = \", dimensions, \",\\tAccuracy = \", accuracy, \"%\",\n",
        "        \",\\tTime = \", pca_time[-1])"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "For PCA Dimensions =  1 ,\tAccuracy =  17.92 % ,\tTime =  5.736214876174927\n",
            "For PCA Dimensions =  2 ,\tAccuracy =  26.82 % ,\tTime =  6.093822002410889\n",
            "For PCA Dimensions =  3 ,\tAccuracy =  33.71 % ,\tTime =  6.186917304992676\n",
            "For PCA Dimensions =  4 ,\tAccuracy =  40.5 % ,\tTime =  6.796564340591431\n",
            "For PCA Dimensions =  5 ,\tAccuracy =  46.39 % ,\tTime =  7.010085821151733\n",
            "For PCA Dimensions =  10 ,\tAccuracy =  66.41 % ,\tTime =  11.422756433486938\n",
            "For PCA Dimensions =  20 ,\tAccuracy =  79.76 % ,\tTime =  13.33506965637207\n",
            "For PCA Dimensions =  50 ,\tAccuracy =  86.85 % ,\tTime =  24.08836054801941\n",
            "For PCA Dimensions =  75 ,\tAccuracy =  87.99 % ,\tTime =  31.516268730163574\n",
            "For PCA Dimensions =  100 ,\tAccuracy =  88.5 % ,\tTime =  38.66898822784424\n",
            "For PCA Dimensions =  150 ,\tAccuracy =  88.75 % ,\tTime =  53.514235734939575\n",
            "For PCA Dimensions =  200 ,\tAccuracy =  88.75 % ,\tTime =  69.56403136253357\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qZuYKj5d5Eq7"
      },
      "source": [
        "Plot of test time accuracy for each PCA dimension."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 294
        },
        "id": "_jBrAeu55DU_",
        "outputId": "b97b13a3-f6a2-456d-e76e-933bbffeea71"
      },
      "source": [
        "f = plt.figure()\n",
        "\n",
        "matplotlib.style.use('seaborn')\n",
        "plt.plot(pca_time, pca_accuracy, 'o--', markersize=5)\n",
        "for label, x, y in zip(pca_dimensions, pca_time, pca_accuracy):\n",
        "    plt.annotate(label, xy=(x, y), ha='right', va='bottom')\n",
        "plt.title('Test Time vs Accuracy for each PCA dimension')\n",
        "plt.xlabel('Test Time')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.grid(True)\n",
        "plt.show()\n",
        "\n",
        "f.savefig(\"pca-test_time_vs_acc.pdf\", bbox_inches='tight')\n",
        "f.savefig(\"pca-test_time_vs_acc.png\", bbox_inches='tight')"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KhrVkCny558o"
      },
      "source": [
        "As it can be observed in the graph, increasing dimensions beyond feature length of 100 results in very little imporvement in accuracy. \n",
        "With 20 times lesser dimensions (100) of feature vector instead of original (2048), the accuracy almost remained the same but the speed improved  almost 15 times (580/38).\n",
        "\n",
        "Hence, for the rest of the analysis of feature length we will use PCA for dimensionality reduction of feature vectors to 100 dimensions."
      ]
    }
  ]
}