5_Region_Proposal_Comparison.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# USAGE\n",
    "# python region_proposal_detection.py --image beagle.png\n",
    "\n",
    "# import the necessary packages\n",
    "from tensorflow.keras.applications import ResNet50\n",
    "from tensorflow.keras.applications.resnet50 import preprocess_input\n",
    "from tensorflow.keras.applications import imagenet_utils\n",
    "from tensorflow.keras.preprocessing.image import img_to_array\n",
    "from imutils.object_detection import non_max_suppression\n",
    "\n",
    "import numpy as np\n",
    "import argparse\n",
    "import cv2\n",
    "\n",
    "import matplotlib.pyplot as plt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example execution\n",
    "args = dict()\n",
    "args['image'] = 'data/test.jpg'\n",
    "args['method'] = 'fast'   # Other choice is quality\n",
    "args['conf'] = 0.9\n",
    "args['filter'] = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def selective_search(image, method=\"fast\"):\n",
    "\t# initialize OpenCV's selective search implementation and set the\n",
    "\t# input image\n",
    "\tss = cv2.ximgproc.segmentation.createSelectiveSearchSegmentation()\n",
    "\tss.setBaseImage(image)\n",
    "\n",
    "\t# check to see if we are using the *fast* but *less accurate* version\n",
    "\t# of selective search\n",
    "\tif method == \"fast\":\n",
    "\t\tss.switchToSelectiveSearchFast()\n",
    "\n",
    "\t# otherwise we are using the *slower* but *more accurate* version\n",
    "\telse:\n",
    "\t\tss.switchToSelectiveSearchQuality()\n",
    "\n",
    "\t# run selective search on the input image\n",
    "\trects = ss.process()\n",
    "\n",
    "\t# return the region proposal bounding boxes\n",
    "\treturn rects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] performing selective search with 'fast' method...\n",
      "2.163592086 seconds\n",
      "[INFO] 2489 regions found by selective search\n"
     ]
    }
   ],
   "source": [
    "# speed-up using multithreads\n",
    "#cv2.setUseOptimized(True);\n",
    "#cv2.setNumThreads(4);\n",
    "\n",
    "args['method'] = 'fast'   # Other choice is quality\n",
    "\n",
    "# load the input image from disk and grab its dimensions\n",
    "image = cv2.imread(args['image'])\n",
    "(H, W) = image.shape[:2]\n",
    "\n",
    "# run selective search on the input image\n",
    "print(\"[INFO] performing selective search with '{}' method...\".format(\n",
    "\targs[\"method\"]))\n",
    "\n",
    "e1 = cv2.getTickCount()\n",
    "rects = selective_search(image, method=args[\"method\"])\n",
    "e2 = cv2.getTickCount()\n",
    "\n",
    "time = (e2 - e1)/ cv2.getTickFrequency()\n",
    "\n",
    "print( time, \"seconds\")\n",
    "\n",
    "\n",
    "print(\"[INFO] {} regions found by selective search\".format(len(rects)))\n",
    "\n",
    "selectiveWindowsFast = len(rects)\n",
    "# get number of windows for the quality selective search\n",
    "rects = selective_search(image, method='quality')\n",
    "selectiveWindowsQuality = len(rects)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def windowSearch(windowSize, S, image):\n",
    "    \n",
    "    # create a new list for rectangles to be used by the roi function later\n",
    "    rects = []\n",
    "    \n",
    "    # loop through the entire image by stride S and add this rectangle to the list\n",
    "    for y in range(0, (image.shape[0] - windowSize[0]), S):\n",
    "        for x in range(0, (image.shape[1] - windowSize[1]), S):\n",
    "            rects.append((x, y, windowSize[0], windowSize[1]))\n",
    "    \n",
    "    return rects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[215158, 53879, 13590, 3420, 874, 228]  Number of Window Search Windows Found\n",
      "2489  Number of Selective Search Fast Windows Found\n",
      "9936  Number of Selective Search Quality Windows Found\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "S = [1, 2, 4, 8, 16, 32]\n",
    "windowSize = (128, 128)\n",
    "numWindows = []\n",
    "for stride in S:\n",
    "    numWindows.append(len(windowSearch(windowSize, stride, image)))\n",
    "\n",
    "print(numWindows, ' Number of Window Search Windows Found')\n",
    "print(selectiveWindowsFast, ' Number of Selective Search Fast Windows Found')\n",
    "print(selectiveWindowsQuality, ' Number of Selective Search Quality Windows Found')\n",
    "\n",
    "\n",
    "plt.title('Window Numbers')\n",
    "plt.xlabel('Strides')\n",
    "plt.plot(S, numWindows, color='orange', label='Windowing')\n",
    "plt.plot(S, [selectiveWindowsFast for x in range(0, len(S))], color='blue', label='Selective Fast')\n",
    "plt.plot(S, [selectiveWindowsQuality for x in range(0, len(S))], color='red', label='Selective Quality')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Preliminary Testing Results\n",
    "\n",
    "So far we found the number of windows to use for our classifier in the future. We can see the selective search takes a much longer time to create a list of search areas, however the list tends to be shorter than the smaller strides of the windowing approach. Using a very small stride shows an extremely large amount of windows to be searched and would later slow down our classifier as it has a lot more to sift through"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def roiFilter(rects, size=(224, 224)):\n",
    "    # initialize the list of region proposals that we'll be classifying\n",
    "    # along with their associated bounding boxes\n",
    "    proposals = []\n",
    "    boxes = []\n",
    "\n",
    "    # loop over the region proposal bounding box coordinates generated by\n",
    "    # running selective search\n",
    "    for (x, y, w, h) in rects:\n",
    "        # if the width or height of the region is less than 10% of the\n",
    "        # image width or height, ignore it (i.e., filter out small\n",
    "        # objects that are likely false-positives)\n",
    "        if w / float(W) < 0.1 or h / float(H) < 0.1:\n",
    "            continue\n",
    "\n",
    "        # extract the region from the input image, convert it from BGR to\n",
    "        # RGB channel ordering, and then resize it to 224x224 (the input\n",
    "        # dimensions required by our pre-trained CNN)\n",
    "        roi = image[y:y + h, x:x + w]\n",
    "        roi = cv2.cvtColor(roi, cv2.COLOR_BGR2RGB)\n",
    "        roi = cv2.resize(roi, size)\n",
    "\n",
    "        # further preprocess by the ROI\n",
    "        roi = img_to_array(roi)\n",
    "        roi = preprocess_input(roi)\n",
    "\n",
    "        # update our proposals and bounding boxes lists\n",
    "        proposals.append(roi)\n",
    "        boxes.append((x, y, w, h))\n",
    "\n",
    "    # convert the proposals list into NumPy array and show its dimensions\n",
    "    proposals = np.array(proposals)\n",
    "    print(\"[INFO] proposal shape: {}\".format(proposals.shape))\n",
    "    \n",
    "    return proposals, boxes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] loading ResNet...\n"
     ]
    }
   ],
   "source": [
    "# grab the label filters command line argument\n",
    "labelFilters = args[\"filter\"]\n",
    "\n",
    "# if the label filter is not empty, break it into a list\n",
    "if labelFilters is not None:\n",
    "\tlabelFilters = labelFilters.lower().split(\",\")\n",
    "    \n",
    "# load ResNet from disk (with weights pre-trained on ImageNet)\n",
    "print(\"[INFO] loading ResNet...\")\n",
    "model = ResNet50(weights=\"imagenet\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setting this will limit the search to just one category\n",
    "labelFilters = ['beagle']\n",
    "confidence = args[\"conf\"]     # 0.90 is the default from args"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def labelBoxes(preds, boxes, labelFilters, confidence):\n",
    "    # initialize a dictionary which maps class labels (keys) to any\n",
    "    # bounding box associated with that label (values)\n",
    "    labels = {}\n",
    "    filterRemoved = 0\n",
    "        \n",
    "    # loop over the predictions\n",
    "    for (i, p) in enumerate(preds):\n",
    "        # grab the prediction information for the current region proposal\n",
    "        (imagenetID, label, prob) = p[0]\n",
    "\n",
    "        # only if the label filters are not empty *and* the label does not\n",
    "        # exist in the list, then ignore it\n",
    "        if labelFilters is not None and label not in labelFilters:\n",
    "            filterRemoved = filterRemoved + 1\n",
    "            continue\n",
    "\n",
    "        # filter out weak detections by ensuring the predicted probability\n",
    "        # is greater than the minimum probability\n",
    "        if prob >= confidence:\n",
    "            # grab the bounding box associated with the prediction and\n",
    "            # convert the coordinates\n",
    "            (x, y, w, h) = boxes[i]\n",
    "            box = (x, y, x + w, y + h)\n",
    "\n",
    "            # grab the list of predictions for the label and add the\n",
    "            # bounding box + probability to the list\n",
    "            L = labels.get(label, [])\n",
    "            L.append((box, prob))\n",
    "            labels[label] = L\n",
    "\n",
    "    return labels, filterRemoved"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] proposal shape: (877, 224, 224, 3)\n",
      "[INFO] classifying proposals...\n",
      "[INFO] proposal shape: (4173, 224, 224, 3)\n",
      "[INFO] classifying proposals...\n",
      "[2489, 877, 167, 31, 3]  Regions at each stage Fast\n",
      "[9936, 4173, 1054, 245, 3]  Regions at each stage Quality\n"
     ]
    }
   ],
   "source": [
    "# create lists to keep track of the amount of regions we are interested in\n",
    "selectiveWindowsFast = []\n",
    "selectiveWindowsQuality = []\n",
    "\n",
    "# --- Test the Fast setting ---\n",
    "rects = selective_search(image, method='fast')\n",
    "selectiveWindowsFast.append(len(rects))\n",
    "proposals, boxes = roiFilter(rects)\n",
    "selectiveWindowsFast.append(len(proposals))\n",
    "\n",
    "# classify each of the proposal ROIs using ResNet and then decode the\n",
    "# predictions\n",
    "print(\"[INFO] classifying proposals...\")\n",
    "preds = model.predict(proposals)\n",
    "preds = imagenet_utils.decode_predictions(preds, top=1)\n",
    "\n",
    "labels, numRemoved = labelBoxes(preds, boxes, labelFilters, confidence)\n",
    "# keep track of the number of proposals after filtering labels\n",
    "selectiveWindowsFast.append(selectiveWindowsFast[-1] - numRemoved)\n",
    "selectiveWindowsFast.append(len(labels['beagle']))\n",
    "# Run non-max supression\n",
    "for label in labels.keys():\n",
    "    boxes = np.array([p[0] for p in labels[label]])\n",
    "    proba = np.array([p[1] for p in labels[label]])\n",
    "    boxes = non_max_suppression(boxes, proba)\n",
    "selectiveWindowsFast.append(len(boxes))\n",
    "\n",
    "\n",
    "# --- Test the quality setting ---\n",
    "rects = selective_search(image, method='quality')\n",
    "selectiveWindowsQuality.append(len(rects))\n",
    "proposals, boxes = roiFilter(rects)\n",
    "\n",
    "# classify each of the proposal ROIs using ResNet and then decode the\n",
    "# predictions\n",
    "print(\"[INFO] classifying proposals...\")\n",
    "preds = model.predict(proposals)\n",
    "preds = imagenet_utils.decode_predictions(preds, top=1)\n",
    "\n",
    "selectiveWindowsQuality.append(len(proposals))\n",
    "labels, numRemoved = labelBoxes(preds, boxes, labelFilters, confidence)\n",
    "selectiveWindowsQuality.append(selectiveWindowsQuality[-1] - numRemoved)\n",
    "selectiveWindowsQuality.append(len(labels['beagle']))\n",
    "# Run non-max supression\n",
    "for label in labels.keys():\n",
    "    boxes = np.array([p[0] for p in labels[label]])\n",
    "    proba = np.array([p[1] for p in labels[label]])\n",
    "    boxes = non_max_suppression(boxes, proba)\n",
    "selectiveWindowsQuality.append(len(boxes))\n",
    "\n",
    "print(selectiveWindowsFast, ' Regions at each stage Fast')\n",
    "print(selectiveWindowsQuality, ' Regions at each stage Quality')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "stages = ['Search', 'Small Window', 'Non-Class', 'Confidence', 'After NMS']\n",
    "plt.title('Region Numbers')\n",
    "plt.xlabel('Stage')\n",
    "plt.plot(stages, selectiveWindowsFast, color='orange', label='Fast')\n",
    "plt.plot(stages, selectiveWindowsQuality, color='blue', label='Quality')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Region analysis\n",
    "We started by running the selective search and then slowly widdling the results down futher step by step. The above graph shows the number of regions we're interested in at each step. Interestingly enough, we observe that both the fast and the quality reduced down to the same number of final regions at the end even though it was very obvious while running the code how much faster the \"fast\" setting was at completing the task. We will explore this timing further later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] proposal shape: (877, 224, 224, 3)\n",
      "[INFO] proposal shape: (4173, 224, 224, 3)\n"
     ]
    }
   ],
   "source": [
    "confidenceFast = []\n",
    "confidenceQuality = []\n",
    "confidence = [0.7, 0.74, 0.78, 0.81, 0.84, 0.87, 0.90, 0.93, 0.96, 0.99]\n",
    "\n",
    "rects = selective_search(image, method='fast')\n",
    "proposals, boxes = roiFilter(rects)\n",
    "# classify each of the proposal ROIs using ResNet and then decode the\n",
    "# predictions\n",
    "preds = model.predict(proposals)\n",
    "preds = imagenet_utils.decode_predictions(preds, top=1)\n",
    "for conf in confidence:\n",
    "    labels, _ = labelBoxes(preds, boxes, labelFilters, conf)\n",
    "    try:\n",
    "        confidenceFast.append(len(labels['beagle']))\n",
    "    except:\n",
    "        confidenceFast.append(0)\n",
    "        \n",
    "\n",
    "rects = selective_search(image, method='quality')\n",
    "proposals, boxes = roiFilter(rects)\n",
    "# classify each of the proposal ROIs using ResNet and then decode the\n",
    "# predictions\n",
    "preds = model.predict(proposals)\n",
    "preds = imagenet_utils.decode_predictions(preds, top=1)\n",
    "for conf in confidence:\n",
    "    labels, _ = labelBoxes(preds, boxes, labelFilters, conf)\n",
    "    try:\n",
    "        confidenceQuality.append(len(labels['beagle']))\n",
    "    except:\n",
    "        confidenceQuality.append(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.title('Regions After Confidence Filter')\n",
    "plt.xlabel('Confidence Level')\n",
    "plt.plot(confidence, confidenceFast, color='orange', label='Fast')\n",
    "plt.plot(confidence, confidenceQuality, color='blue', label='Quality')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Confidence Effect on Regions\n",
    "Here we cycled through many options for the level of confidence we wanted to rule out boxes that don't meet this level. It was tested with both the 'fast' and 'quality' versions of the selective search algorithm. As can be seen in the above graph, we observe a close to linear relationship between the number of regions still left, and the confidence level we required. It turns out a confidence level of 0.99 was too high for both as they no longer had any regions left that were above this level."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# receives in two lists of tuples\n",
    "# [(min corner), (max corner)]\n",
    "def IOU(ground_truth, prediction):\n",
    "    \n",
    "    # find our min/max values of the corners to find differences for intersection\n",
    "    minX = min(ground_truth[1][0], prediction[1][0])\n",
    "    minY = min(ground_truth[1][1], prediction[1][1])\n",
    "\n",
    "    maxX = max(ground_truth[0][0], prediction[0][0])\n",
    "    maxY = max(ground_truth[0][1], prediction[0][1])\n",
    "\n",
    "    # max calculation catches if there is no intersection\n",
    "    intArea = max(0, (minX - maxX)) * max(0, (minY - maxY))\n",
    "\n",
    "    # calculate the area of the two rectangles using the differences beterrn corners\n",
    "    truthArea = (ground_truth[1][0] - ground_truth[0][0]) * (ground_truth[1][1] - ground_truth[0][1])\n",
    "    predictArea = (prediction[1][0] - prediction[0][0]) * (prediction[1][1] - prediction[0][1])\n",
    "\n",
    "    # union area equals both areas minus intersection area\n",
    "    unionArea = truthArea + predictArea - intArea\n",
    "\n",
    "    return(intArea/unionArea)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def IOUWrapper(boxes, scoreThresh):\n",
    "    \n",
    "    # count of boxes with < threshold\n",
    "    counter = 0\n",
    "    \n",
    "    # cycle through all the boxes comparing each to the next \n",
    "    for i in range(0, len(boxes)):\n",
    "        box1 = [(boxes[i][0], boxes[i][1]), (boxes[i][2], boxes[i][3])]\n",
    "        subList = []\n",
    "        for j in range(0, len(boxes)):\n",
    "            # skip checking the current against itself\n",
    "            if j == i:\n",
    "                continue\n",
    "            box2 = [(boxes[j][0], boxes[j][1]), (boxes[j][2], boxes[j][3])]\n",
    "            subList.append(IOU(box1, box2))\n",
    "        \n",
    "        count = len([k for k in subList if k > scoreThresh])\n",
    "        if count == 0:\n",
    "            counter = counter + 1\n",
    "    \n",
    "    percentage = (counter / len(boxes)) * 100\n",
    "    \n",
    "    return(percentage)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] proposal shape: (877, 224, 224, 3)\n",
      "[INFO] classifying proposals...\n",
      "The percentage of boxes that are above the 25.0 % threshold is: 3.225806451612903 %\n"
     ]
    }
   ],
   "source": [
    "confidence = args[\"conf\"]     # 0.90 is the default from args\n",
    "# score threshold for scoring the IOU comparisions\n",
    "scoreThresh = 0.25\n",
    "\n",
    "rects = selective_search(image, method='fast')\n",
    "proposals, boxes = roiFilter(rects)\n",
    "\n",
    "# classify each of the proposal ROIs using ResNet and then decode the\n",
    "# predictions\n",
    "print(\"[INFO] classifying proposals...\")\n",
    "preds = model.predict(proposals)\n",
    "preds = imagenet_utils.decode_predictions(preds, top=1)\n",
    "\n",
    "labels, _ = labelBoxes(preds, boxes, labelFilters, confidence)\n",
    "# keep track of the number of proposals after filtering labels\n",
    "beforeIOU = len(labels['beagle']) \n",
    "\n",
    "# Run IOU calculation\n",
    "for label in labels.keys():\n",
    "    boxes = np.array([p[0] for p in labels[label]])\n",
    "    #print(boxes)\n",
    "    proba = np.array([p[1] for p in labels[label]])\n",
    "    count = IOUWrapper(boxes, scoreThresh)\n",
    "\n",
    "print(\"The percentage of boxes that are above the\", scoreThresh*100, \"% threshold is:\", count, \"%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### IOU Comparision\n",
    "In the above few cells we run the beagle matches through an IOU calculation against every other box in the same label. Then the percentage of boxes that have less than the 25% threshold are returned, and it shows to be quite a low number. This shows that about one of the boxes is truly significant, and the others are all overlapping another box by more than 25%"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] proposal shape: (877, 224, 224, 3)\n",
      "[INFO] classifying proposals...\n",
      "[INFO] proposal shape: (4173, 224, 224, 3)\n",
      "[INFO] classifying proposals...\n"
     ]
    }
   ],
   "source": [
    "# --- Test the Fast setting ---\n",
    "rects = selective_search(image, method='fast')\n",
    "proposals, boxes = roiFilter(rects)\n",
    "\n",
    "e1 = cv2.getTickCount()\n",
    "# classify each of the proposal ROIs using ResNet and then decode the\n",
    "# predictions\n",
    "print(\"[INFO] classifying proposals...\")\n",
    "preds = model.predict(proposals)\n",
    "preds = imagenet_utils.decode_predictions(preds, top=1)\n",
    "e2 = cv2.getTickCount()\n",
    "timeFast = (e2 - e1)/ cv2.getTickFrequency()\n",
    "\n",
    "# --- Test the Quality setting ---\n",
    "rects = selective_search(image, method='quality')\n",
    "proposals, boxes = roiFilter(rects)\n",
    "\n",
    "e1 = cv2.getTickCount()\n",
    "# classify each of the proposal ROIs using ResNet and then decode the\n",
    "# predictions\n",
    "print(\"[INFO] classifying proposals...\")\n",
    "preds = model.predict(proposals)\n",
    "preds = imagenet_utils.decode_predictions(preds, top=1)\n",
    "e2 = cv2.getTickCount()\n",
    "timeQuality = (e2 - e1)/ cv2.getTickFrequency()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x_label = ['fast', 'quality']\n",
    "times = [timeFast, timeQuality]\n",
    "perProposal = [(timeFast / 877), (timeQuality / 4173)]\n",
    "\n",
    "# create a subplot\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.bar(x_label, times, color='blue', label='Raw')\n",
    "plt.xlabel(\"Algorithm\")\n",
    "plt.ylabel(\"Time [s]\")\n",
    "plt.title(\"Prediction Time for Selective Search\")\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.bar(x_label, perProposal, color='red', label='Raw')\n",
    "plt.xlabel(\"Algorithm\")\n",
    "plt.ylabel(\"Time [s]\")\n",
    "plt.title(\"Prediction Time Per Proposal\")\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prediction Timing\n",
    "Like we noticed before, the prediction function runs much quicker with fewer regions to analyze. The timing remains linear as we can see in the \"prediction time per proposal\" being essentially the same between the two. This is showing the time a prediction took for each area we scanned. So, like we found previously, having fewer regions to process we can save valuable time but with the cost of potential loss of accuracy or precision"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}