bovw-classification.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Falling back to using features:  <ORB 0000025E74AA4F90>\nFor BoVW, use feature:  <ORB 0000025E74AA4F90>\n"
     ]
    }
   ],
   "source": [
    "# Importing dependencies\n",
    "import cv2\n",
    "import os\n",
    "import numpy as np\n",
    "from tqdm import tqdm\n",
    "from utils import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "4.5.2\n"
     ]
    }
   ],
   "source": [
    "# Check OpenCV version, should be >= 3.3.0\n",
    "print(cv2.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Loaded 10000 images\nTook 10.2s\n"
     ]
    }
   ],
   "source": [
    "# Loading images -> neg, pos\n",
    "paths = [params.DATA_TRAINING_PATH_NEG, params.DATA_TRAINING_PATH_POS]\n",
    "\n",
    "# Build a list of class_names\n",
    "class_names = [get_class_name(class_number) for class_number in range(len(params.DATA_CLASS_NAMES))]\n",
    "\n",
    "# Specify number of subwindow samples to take\n",
    "# Use 0 to take the whole image\n",
    "sampling_sizes = [0, 0]\n",
    "\n",
    "# Take samples from center\n",
    "sample_from_center = [True, True]\n",
    "\n",
    "# Perform image loading\n",
    "start_load = cv.getTickCount()\n",
    "imgs_data = load_images(paths, \n",
    "                        class_names, \n",
    "                        sampling_sizes, \n",
    "                        sample_from_center, \n",
    "                        params.DATA_WINDOW_OFFSET_FOR_TRAINING_SAMPLES, \n",
    "                        params.DATA_WINDOW_SIZE)\n",
    "\n",
    "print(('Loaded {} images'.format(len(imgs_data))))\n",
    "print_duration(start_load)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stderr",
     "text": [
      "  0%|          | 0/10000 [00:00<?, ?it/s]\n",
      "Computing descriptors ...\n",
      "100%|██████████| 10000/10000 [00:20<00:00, 485.72it/s]\n",
      "Took 20.6s\n",
      "\n",
      "Clustering ...\n",
      "  0%|          | 32/10000 [00:00<00:31, 316.84it/s]Took 12m:25.5s\n",
      "\n",
      "Generating histograms ...\n",
      "100%|██████████| 10000/10000 [00:32<00:00, 309.61it/s]Took 32.3s\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Perform Bag of Visual Words feature construction\n",
    "\n",
    "print('\\nComputing descriptors ...')\n",
    "start_describe = cv.getTickCount()\n",
    "[img_data.compute_bovw_descriptor() for img_data in tqdm(imgs_data)]\n",
    "print_duration(start_describe)\n",
    "\n",
    "print('\\nClustering ...')\n",
    "start_cluster = cv.getTickCount()\n",
    "dictionary = generate_dictionary(imgs_data, params.BOVW_DICTIONARY_SIZE)\n",
    "print_duration(start_cluster)\n",
    "\n",
    "print('\\nGenerating histograms ...')\n",
    "start_hist = cv.getTickCount()\n",
    "[img_data.generate_bovw_hist(dictionary) for img_data in tqdm(imgs_data)]\n",
    "print_duration(start_hist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Took 36m:52.1s\n"
     ]
    }
   ],
   "source": [
    "# Train an SVM based on features\n",
    "start_svm = cv.getTickCount()\n",
    "\n",
    "svm = cv.ml.SVM_create()\n",
    "svm.setType(cv.ml.SVM_C_SVC)\n",
    "svm.setKernel(params.BOVW_SVM_KERNEL)\n",
    "\n",
    "# Compile samples for each training image\n",
    "samples = get_bovw_histograms(imgs_data)\n",
    "\n",
    "# Get class label for each training image\n",
    "class_labels = get_class_labels(imgs_data)\n",
    "\n",
    "# Specify term criteria for training\n",
    "svm.setTermCriteria((cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_COUNT, params.BOVW_SVM_MAX_TRAINING_ITERATIONS, 1.e-06))\n",
    "\n",
    "# Perform autotraining\n",
    "svm.trainAuto(samples, cv.ml.ROW_SAMPLE, class_labels, kFold=10, balanced=True)\n",
    "\n",
    "# Save trained SVM\n",
    "svm.save(params.BOVW_SVM_PATH)\n",
    "print_duration(start_svm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Trained SVM obtained 6.88% error in train dataset\n-- and the accuracy is 93.12%.\n"
     ]
    }
   ],
   "source": [
    "# Performance measure of the SVM\n",
    "output = svm.predict(samples)[1].ravel()\n",
    "error = (np.absolute(class_labels.ravel() - output).sum()) / float(output.shape[0])\n",
    "\n",
    "if error < (1.0 / len(params.DATA_CLASS_NAMES)):\n",
    "    print('Trained SVM obtained {}% error in train dataset'.format(round(error*100, 2)))\n",
    "    print('-- and the accuracy is {}%.'.format(round((1.0 - error)*100,2)))\n",
    "else:\n",
    "    print('Failed to train SVM. {}% error'.format(round(1.0 - error)*100, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Loaded 992 images\nTook 0.8s\n"
     ]
    }
   ],
   "source": [
    "# Loading testing data\n",
    "DATA_TESTING_PATH_NEG = '.\\\\dataset\\\\Test\\\\WithoutMask'\n",
    "DATA_TESTING_PATH_POS = '.\\\\dataset\\\\Test\\\\WithMask'\n",
    "\n",
    "test_paths = [DATA_TESTING_PATH_NEG, DATA_TESTING_PATH_POS]\n",
    "\n",
    "# Perform image loading\n",
    "start_load = cv.getTickCount()\n",
    "imgs_test = load_images(test_paths, \n",
    "                        class_names, \n",
    "                        sampling_sizes, \n",
    "                        sample_from_center, \n",
    "                        params.DATA_WINDOW_OFFSET_FOR_TRAINING_SAMPLES, \n",
    "                        params.DATA_WINDOW_SIZE)\n",
    "\n",
    "print(('Loaded {} images'.format(len(imgs_test))))\n",
    "print_duration(start_load)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stderr",
     "text": [
      " 20%|██        | 203/992 [00:00<00:00, 822.04it/s]\n",
      "Computing descriptors ...\n",
      "100%|██████████| 992/992 [00:01<00:00, 657.24it/s]\n",
      "  5%|▌         | 52/992 [00:00<00:01, 509.86it/s]Took 1.5s\n",
      "\n",
      "Generating histograms ...\n",
      "100%|██████████| 992/992 [00:02<00:00, 393.18it/s]Took 2.5s\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Perform feature extraction\n",
    "print('\\nComputing descriptors ...')\n",
    "start_describe = cv.getTickCount()\n",
    "[img_test.compute_bovw_descriptor() for img_test in tqdm(imgs_test)]\n",
    "print_duration(start_describe)\n",
    "\n",
    "# Genenrating histogram using generated dictionary\n",
    "print('\\nGenerating histograms ...')\n",
    "start_hist = cv.getTickCount()\n",
    "[img_test.generate_bovw_hist(dictionary) for img_test in tqdm(imgs_test)]\n",
    "print_duration(start_hist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Trained SVM obtained 9.27% error in train dataset\n-- and the accuracy is 90.73%.\n"
     ]
    }
   ],
   "source": [
    "# Compile samples for each training image\n",
    "test = get_bovw_histograms(imgs_test)\n",
    "# Get class label for each training image\n",
    "class_labels = get_class_labels(imgs_test)\n",
    "\n",
    "# Performance measure of the SVM on new data\n",
    "output_test = svm.predict(test)[1].ravel()\n",
    "error_test = (np.absolute(class_labels.ravel() - output_test).sum()) / float(output_test.shape[0])\n",
    "\n",
    "if error_test < (1.0 / len(params.DATA_CLASS_NAMES)):\n",
    "    print('Trained SVM obtained {}% error in train dataset'.format(round(error_test*100, 2)))\n",
    "    print('-- and the accuracy is {}%.'.format(round((1.0 - error_test)*100,2)))\n",
    "else:\n",
    "    print('Failed to train SVM. {}% error'.format(round(1.0 - error_test)*100, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3.8.5 64-bit ('base': conda)"
  },
  "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.5"
  },
  "interpreter": {
   "hash": "b3ba2566441a7c06988d0923437866b63cedc61552a5af99d1f4fb67d367b25f"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}