diff --git "a/15_Object_Detection_Sliding_Window.ipynb" "b/15_Object_Detection_Sliding_Window.ipynb" new file mode 100644--- /dev/null +++ "b/15_Object_Detection_Sliding_Window.ipynb" @@ -0,0 +1,689 @@ +{ + "cells": [ + { + "cell_type": "raw", + "id": "7eeb675e", + "metadata": {}, + "source": [ + "---\n", + "title: 16 Object Detection using Sliding Window and Image Pyramid\n", + "description: Object Detection using Sliding Window and Image Pyramid\n", + "---" + ] + }, + { + "cell_type": "markdown", + "id": "f7ecac9b", + "metadata": {}, + "source": [ + "\"Colab\"" + ] + }, + { + "cell_type": "markdown", + "id": "FcvyQBNm9Atn", + "metadata": { + "id": "FcvyQBNm9Atn" + }, + "source": [ + "\"Kaggle\"" + ] + }, + { + "cell_type": "markdown", + "id": "93c3dbee", + "metadata": { + "id": "93c3dbee", + "papermill": { + "duration": 0.01012, + "end_time": "2022-04-01T17:42:45.866956", + "exception": false, + "start_time": "2022-04-01T17:42:45.856836", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "# Object Detection using Sliding Window\n", + "\n", + "We will be using concepts of Image Pyramid, Sliding Window and Non-Maxima Supression to turn almost any Image Classifier into an Object Detector\n", + "* **Image Pyramid**: \n", + " * An image pyramid is a multi-scale representation of an image, allowing us to find objects in images at different scales of an image.\n", + " * At the bottom of the pyramid, we have the original image at its original size (in terms of width and height).\n", + " * And at each subsequent layer, the image is resized (subsampled) and optionally smoothed (usually via Gaussian blurring).\n", + " * The image is progressively subsampled until some stopping criterion is met, which is normally when a minimum size has been reached and no further subsampling needs to take place.\n", + "* **Sliding Window**:\n", + " * A sliding window is a fixed-size rectangle that slides from left-to-right and top-to-bottom within an image.\n", + " * At each stop of the window we would:\n", + " * Extract the ROI\n", + " * Pass it through our image classifier\n", + " * Obtain the output predictions\n", + "* **Non-Maxima Supression**:\n", + " * When performing object detection, our object detector will typically produce multiple, overlapping bounding boxes surrounding an object in an image.\n", + " * We somehow need to collapse/remove the extraneous bounding boxes.\n", + " * Non-maxima suppression (NMS) collapses weak, overlapping bounding boxes in favor of the more confident ones.\n", + " \n", + "**Credits**: [PyImageSearch](https://pyimagesearch.com/2020/06/22/turning-any-cnn-image-classifier-into-an-object-detector-with-keras-tensorflow-and-opencv/)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "82932eb0", + "metadata": { + "_kg_hide-input": true, + "_kg_hide-output": true, + "execution": { + "iopub.execute_input": "2022-04-01T17:42:45.899172Z", + "iopub.status.busy": "2022-04-01T17:42:45.898186Z", + "iopub.status.idle": "2022-04-01T17:42:58.586800Z", + "shell.execute_reply": "2022-04-01T17:42:58.587362Z", + "shell.execute_reply.started": "2022-04-01T17:42:02.081289Z" + }, + "id": "82932eb0", + "papermill": { + "duration": 12.7104, + "end_time": "2022-04-01T17:42:58.587681", + "exception": false, + "start_time": "2022-04-01T17:42:45.877281", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "%%capture\n", + "!pip install imutils huggingface_hub" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "df5efe58", + "metadata": { + "execution": { + "iopub.execute_input": "2022-04-01T17:42:58.610193Z", + "iopub.status.busy": "2022-04-01T17:42:58.609209Z", + "iopub.status.idle": "2022-04-01T17:43:04.978679Z", + "shell.execute_reply": "2022-04-01T17:43:04.978130Z", + "shell.execute_reply.started": "2022-04-01T17:41:40.301256Z" + }, + "id": "df5efe58", + "papermill": { + "duration": 6.381808, + "end_time": "2022-04-01T17:43:04.978830", + "exception": false, + "start_time": "2022-04-01T17:42:58.597022", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import argparse\n", + "import imutils\n", + "import time\n", + "import cv2\n", + "\n", + "import tensorflow as tf\n", + "from huggingface_hub import from_pretrained_keras\n", + "\n", + "from imutils.object_detection import non_max_suppression\n", + "\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4c7a8215", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 217 + }, + "execution": { + "iopub.execute_input": "2022-04-01T17:43:05.004078Z", + "iopub.status.busy": "2022-04-01T17:43:05.003426Z", + "iopub.status.idle": "2022-04-01T17:43:05.908783Z", + "shell.execute_reply": "2022-04-01T17:43:05.908167Z", + "shell.execute_reply.started": "2022-04-01T17:41:40.311343Z" + }, + "id": "4c7a8215", + "outputId": "ce91ada6-a3c1-4896-8045-6b07141a50b0", + "papermill": { + "duration": 0.920894, + "end_time": "2022-04-01T17:43:05.908953", + "exception": false, + "start_time": "2022-04-01T17:43:04.988059", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz\n", + "11493376/11490434 [==============================] - 0s 0us/step\n", + "11501568/11490434 [==============================] - 0s 0us/step\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAACRCAYAAADaduOsAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAQLElEQVR4nO3de3BUZZoG8OcFhlGYlRCYiggqWGIotCSOgMJQgANxGUpH8bJlygsoGv8AB6dGFty1tqS8FBbKDigqyCgjUo67g1yKKhfYcLEcNcN9BgIBdQRDxTCjInJRJvLuH32i/X6bdKfTp/ucr/P8qqj0czqd85rT/Xry9dffEVUFERH5p0PUBRARUduwgRMReYoNnIjIU2zgRESeYgMnIvIUGzgRkaeyauAiMk5EakXkAxGZGVZRRESUnrR1HriIdASwH0A5gDoAWwBUqGpNeOUREVFLOmXx2KEAPlDVjwBARH4P4AYALTZwEeGnhoiIMvd3Vf2xuzGbIZTeAD5JynXBNiIiCtfB5jZmcwbeKiJSCaAy1/shImpvsmnghwGcn5T7BNsMVV0EYBHAIRQiojBlM4SyBUB/EeknIp0B3AZgdThlERFROm0+A1fVRhGZCmAtgI4AXlbVPaFVRkREKbV5GmGbdsYhFCKittimqoPdjfwkJhGRp9jAiYg8xQZOROQpNnAiIk+xgRMReYoNnIjIU2zgRESeYgMnIvIUGzgRkafYwImIPMUGTkTkKTZwIiJPsYETEXkq51fkKSQdO3Y0uVu3bhk9furUqSZ36dLF5NLSUpOnTJli8tNPP21yRUWFyV9//bXJs2fPNnnWrFmtL5ZCNWbMGJOXLVtm8qhRo0yura3NeU30vUceecRk97XSoYM91x09erTJmzdvzkld6fAMnIjIU2zgRESeYgMnIvJUuxoDv+CCC0zu3LmzycOHDzd5xIgRJhcVFZl88803h1gdUFdXZ/L8+fNNnjBhgslfffWVybt27TI5qnG5lowcOdLkHj16mLxixYp8lpNXQ4YMMXnLli0RVUIAMGnSJJNnzJhh8pkzZ1I+Pp9XMkuFZ+BERJ5iAyci8hQbOBGRpwp6DLysrMzkDRs2mJzpPO6wueNs7lzU48ePm+zOHa6vrzf5iy++MDluc4ndubP9+/c3uZDGwN15w/369TP5wgsvNFlEcl4Tfc/9/Z911lkRVZIdnoETEXmKDZyIyFNs4EREniroMfBDhw6Z/Nlnn5kc9hh4dXW1yUePHjX5mmuuMfn06dMmL126NNR64uauu+4y+b333ouoktzr1auXyffdd5/Jr732msn79u3LeU3t2dixY01+4IEHUn6/ezyuu+46kxsaGsIpLEs8Ayci8hQbOBGRp9jAiYg8VdBj4J9//rnJ06dPN9kd19qxY4fJ7lokrp07d5pcXl5u8okTJ0y+9NJLTZ42bVrKn19o3LnRhWzx4sUp7z9w4ECeKmmf3HWMXnnlFZPTvf81Z84ckw8ePBhOYSFrP68oIqICk7aBi8jLInJERHYnbSsWkfUiciD42j23ZRIRkas1Z+BLAIxzts0EUKWq/QFUBZmIiPIo7Ri4qr4tIn2dzTcAGB3c/h2ATQBmIOZWrlxpsrs2iru+9qBBg0yePHmyye41Kt0xb9eePXtMrqysTPn9vrv88stNLikpiaiS/Es3xrp+/fo8VdI+TZw40eTzzjsv5fdv2rTJ5FdffTXsknKirWPgJaratJLSpwDazyuTiCgmsp6FoqoqIi1enkJEKgEU9qkmEVEE2noG3iAivQAg+HqkpW9U1UWqOlhVB7dxX0RE1Iy2noGvBjARwOzg66rQKsqjY8eOpbz/yy+/THm/u77FG2+8YXK66+oVuvHjx5t89tlnR1RJ7rnj++76367Dhw/nspx2p2fPnibfc889JruvRXedoscffzw3heVYa6YRvg7gPQClIlInIpORaNzlInIAwNggExFRHrVmFkpFC3eNCbkWIiLKAD+JSUTkqYJeCyVbjz76qMlXXnmlyaNGjTLZXXN43bp1OanLF6WlpSnvd+fF+8z9TIA7Jr5//36T3c8cUGb69u1r8vLlyzN6/LPPPmvyxo0bsy0pEjwDJyLyFBs4EZGn2MCJiDzFMfAU3LVN3Hnf27dvN/mll14y2R1X27p1q8kLFiwwWbXFD7QWpC1btkRdQovOOecck8eNs+u53XHHHSZfe+21KX/eY489ZrI7D5ky4x4Pd90dV1VVlcnz5s0LvaYo8AyciMhTbOBERJ5iAyci8hTHwDPw4Ycfmjxp0iST3evu3XnnnSlz165dTXbXIK6vr0chKy4uzurx7nrtImKyOy+/T58+Jnfu3Pm727fffru5z71+56lTp0yurq42+ZtvvjG5Uyf70tq2bRuo7W688UaTZ89OvXrHO++8Y7K7Pni6dY58wTNwIiJPsYETEXmKDZyIyFOSz7nHqa7cUwguu+wyk+fOnWvymDGpF3BcuHChyU888YTJvq0h/fzzz5t8//33m+zOhT506FBGP9+d++uOgTc2Npp88uRJk2tqar677Y5pu3P2N2/ebHJDQ4PJdXV1Jnfv3t3k5PF2Ss9d68R9/ykd9/2ku+++O9uSoratuYvi8AyciMhTbOBERJ5iAyci8hTHwHOoqKjI5Ouvv95kd964O4a7YcMGk8vLy0OsLv9mzJhh8vDhw0P9+StXrjR57969Jr///vuh7auystLkF1980eSPPvrI5Isvvji0fbcHL7zwgsn33ntvRo9334+qra3NuqaIcQyciKiQsIETEXmKDZyIyFNcCyWH3HnOS5cuNXnx4sUmu+tnjBw50uTRo0ebvGnTpuwKzLOnnnoq6hJCk25Of6bXaGzvysrKTE63vrpr1apVJhfAmHer8AyciMhTbOBERJ5iAyci8hTHwEPkrs1xyy23mDxkyBCT3TFvV/JaHQDw9ttvZ1Ed5dOKFSuiLsEr69atM9ldS8blzul31+ZvL3gGTkTkKTZwIiJPsYETEXmKY+AZKC0tNXnq1Kkm33TTTSafe+65Gf38b7/91mT3mphnzpzJ6OcR+aJHjx4mp3uuu2vNHz9+PPSafMAzcCIiT6Vt4CJyvohsFJEaEdkjItOC7cUisl5EDgRfU79tTEREoWrNGXgjgF+r6kAAVwOYIiIDAcwEUKWq/QFUBZmIiPIk7Ri4qtYDqA9ufyUiewH0BnADgNHBt/0OwCYAM5r5Ed5wx6wrKipMdse83ev2Zcq97qJ7DczVq1dn9fMpf9y13C+55BKTw1yLvBC4a+F36JDZaO67774bZjneyui3JiJ9AVwBoBpASdDcAeBTACWhVkZERCm1ehaKiPwIwHIAD6rqseQzDlXVlq62IyKVACqbu4+IiNquVWfgIvIDJJr3MlV9M9jcICK9gvt7ATjS3GNVdZGqDm7uckBERNR2ac/AJXGq/VsAe1V1btJdqwFMBDA7+LqqmYfHSkmJHeUZOHCgyc8995zJAwYMyGp/1dXVJs+ZM8dkdw1jzvP2l3tt2UzHdAudu9732LFjTXaf+6dPnzZ5wYIFJjc0NIRYnb9aM4TyUwB3AviLiOwMtv0bEo37v0RkMoCDAP4lNyUSEVFzWjML5R0A0sLdqS9LQkREOcO/84iIPFVQa6EUFxebvHDhQpPdcbiLLrooq/25c1GfeeYZk9euXWvyqVOnstof+WPYsGEmL1myJJpCYqKoqMjkdOsEHT582OSHHnoo9JoKAc/AiYg8xQZOROQpNnAiIk95NQZ+1VVXmTx9+nSThw4danLv3r2z2t/JkydNnj9/vslPPvmkySdOnMhqf+Qvdy0UonzgGTgRkafYwImIPMUGTkTkKa/GwCdMmJAyp1NTU2PymjVrTG5sbDTZndd99OjRjPZHheutt94y+dZbb42oEj/s27fPZPczFCNGjMhnOQWDZ+BERJ5iAyci8hQbOBGRp8RdxzinO2vhqj1ERJTStuYuisMzcCIiT7GBExF5ig2ciMhTbOBERJ5iAyci8hQbOBGRp9jAiYg8xQZOROQpNnAiIk+xgRMReYoNnIjIU/leD/zvAA4C6BncjivW13Zxrg1gfdlifdlpa30XNrcxr4tZfbdTka3NLcwSF6yv7eJcG8D6ssX6shN2fRxCISLyFBs4EZGnomrgiyLab2uxvraLc20A68sW68tOqPVFMgZORETZ4xAKEZGn8trARWSciNSKyAciMjOf+26hnpdF5IiI7E7aViwi60XkQPC1e4T1nS8iG0WkRkT2iMi0ONUoImeJyJ9EZFdQ36xgez8RqQ6O8xsi0jmK+oJaOorIDhFZE7fagno+FpG/iMhOEdkabIvL8S0SkT+IyD4R2Ssiw2JUW2nwO2v6d0xEHoxLfUGNvwpeF7tF5PXg9RLq8y9vDVxEOgJYAODnAAYCqBCRgfnafwuWABjnbJsJoEpV+wOoCnJUGgH8WlUHArgawJTgdxaXGr8B8DNVHQSgDMA4EbkawFMA/lNVLwbwBYDJEdUHANMA7E3KcaqtyTWqWpY0vSwux3cegP9R1QEABiHxe4xFbapaG/zOygBcCeAkgBVxqU9EegP4JYDBqnoZgI4AbkPYzz9Vzcs/AMMArE3KDwN4OF/7T1FXXwC7k3ItgF7B7V4AaqOuMam2VQDK41gjgC4AtgO4CokPKnRq7rjnuaY+SLyIfwZgDQCJS21JNX4MoKezLfLjC6AbgL8ieJ8sTrU1U+u1AP4Yp/oA9AbwCYBiJD4wuQbAP4f9/MvnEErTf1CTumBb3JSoan1w+1MAJVEW00RE+gK4AkA1YlRjMESxE8ARAOsBfAjgqKo2Bt8S5XH+DYB/BXAmyD0Qn9qaKIB1IrJNRCqDbXE4vv0A/A3AK8EQ1GIR6RqT2ly3AXg9uB2L+lT1MICnARwCUA/gSwDbEPLzj29ipqCJ/01GPk1HRH4EYDmAB1X1WPJ9Udeoqt9q4s/YPgCGAhgQVS3JROQ6AEdUdVvUtaQxQlV/gsTQ4hQRGZl8Z4THtxOAnwB4QVWvAHACznBE1M89AAjGkH8B4L/d+6KsLxh7vwGJ/xGeB6Ar/v9wbdby2cAPAzg/KfcJtsVNg4j0AoDg65EoixGRHyDRvJep6pvB5ljVCACqehTARiT+LCwSkaZ1dqI6zj8F8AsR+RjA75EYRpkXk9q+E5ypQVWPIDGGOxTxOL51AOpUtTrIf0CiocehtmQ/B7BdVRuCHJf6xgL4q6r+TVX/AeBNJJ6ToT7/8tnAtwDoH7wL2xmJP3tW53H/rbUawMTg9kQkxp0jISIC4LcA9qrq3KS7YlGjiPxYRIqC22cjMT6/F4lGfkuU9anqw6raR1X7IvFc26Cqt8ehtiYi0lVE/qnpNhJjubsRg+Orqp8C+ERESoNNYwDUxKE2RwW+Hz4B4lPfIQBXi0iX4HXc9PsL9/mX54H98QD2IzFO+u9RvLng1PM6EuNT/0DijGMyEuOkVQAOAPhfAMUR1jcCiT8B/wxgZ/BvfFxqBHA5gB1BfbsB/Eew/SIAfwLwARJ/2v4w4uM8GsCauNUW1LIr+Len6TURo+NbBmBrcHxXAugel9qC+roC+AxAt6RtcapvFoB9wWtjKYAfhv384ycxiYg8xTcxiYg8xQZOROQpNnAiIk+xgRMReYoNnIjIU2zgRESeYgMnIvIUGzgRkaf+D5dPsK8AVpFfAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()\n", + "orig = np.zeros((28, 84))\n", + "orig[:, :28] = x_train[0]\n", + "orig[:, 28:56] = x_train[2]\n", + "orig[:, 56:] = x_train[3]\n", + "(H, W) = orig.shape[:2]\n", + "plt.imshow(orig, cmap='gray');" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d1be09f0", + "metadata": { + "execution": { + "iopub.execute_input": "2022-04-01T17:43:05.961927Z", + "iopub.status.busy": "2022-04-01T17:43:05.947126Z", + "iopub.status.idle": "2022-04-01T17:43:05.963991Z", + "shell.execute_reply": "2022-04-01T17:43:05.964431Z", + "shell.execute_reply.started": "2022-04-01T17:41:40.879449Z" + }, + "id": "d1be09f0", + "papermill": { + "duration": 0.043147, + "end_time": "2022-04-01T17:43:05.964614", + "exception": false, + "start_time": "2022-04-01T17:43:05.921467", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "class SlidingWindowObjectDetection():\n", + " def __init__(self, pretrained_classifier_path, **kwargs):\n", + " self.model = from_pretrained_keras(pretrained_classifier_path)\n", + " self.kwargs = kwargs\n", + " \n", + " def sliding_window(self, image, step, ws):\n", + " for y in range(0, image.shape[0] - ws[1], step):\n", + " for x in range(0, image.shape[1] - ws[0], step):\n", + " yield (x, y, image[y:y + ws[1], x:x + ws[0]])\n", + "\n", + " def image_pyramid(self, image, scale=1.5, minSize=(28, 28)):\n", + " yield image\n", + " while True:\n", + " w = int(image.shape[1] / scale)\n", + " image = imutils.resize(image, width=w)\n", + " if image.shape[0] < minSize[1] or image.shape[1] < minSize[0]:\n", + " break\n", + " yield image \n", + " \n", + " def get_rois_and_locs(self, pyramid):\n", + " rois = []\n", + " locs = []\n", + " for image in pyramid:\n", + " scale = W / float(image.shape[1])\n", + " for (x, y, roiOrig) in self.sliding_window(image, self.kwargs['WIN_STEP'], self.kwargs['ROI_SIZE']):\n", + " x = int(x * scale)\n", + " y = int(y * scale)\n", + " w = int(self.kwargs['ROI_SIZE'][0] * scale)\n", + " h = int(self.kwargs['ROI_SIZE'][1] * scale)\n", + "\n", + " roi = cv2.resize(roiOrig, self.kwargs['INPUT_SIZE'])\n", + "\n", + " rois.append(roi)\n", + " locs.append((x, y, x + w, y + h))\n", + " return rois, locs\n", + " \n", + " def visualize_rois(self, rois):\n", + " fig, axes = plt.subplots(1, len(rois), figsize=(20, 6))\n", + " for ax, roi in zip(axes, rois):\n", + " ax.imshow(roi, cmap='gray')\n", + " \n", + " def get_preds(self, rois, locs):\n", + " rois = np.array(rois, dtype=\"float32\")\n", + " preds = self.model.predict(rois)\n", + " preds = list(zip(preds.argmax(axis=1).tolist(), preds.max(axis=1).tolist()))\n", + " labels = {}\n", + "\n", + " for (i, p) in enumerate(preds):\n", + " (label, prob) = p\n", + " if prob >= self.kwargs['MIN_CONF']:\n", + " box = locs[i]\n", + " L = labels.get(label, [])\n", + " L.append((box, prob))\n", + " labels[label] = L\n", + " return preds, labels\n", + " \n", + " def apply_nms(self, labels):\n", + " nms_labels = {}\n", + " for label in sorted(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", + " nms_labels[label] = boxes.tolist()\n", + " return nms_labels\n", + " \n", + " def visualize_preds(self, img, nms_labels):\n", + " for label in sorted(nms_labels.keys()):\n", + " clone = img.copy()\n", + " fig, ax = plt.subplots(figsize=(20, 6))\n", + " boxes = nms_labels[label]\n", + " for (startX, startY, endX, endY) in boxes:\n", + " cv2.rectangle(clone, (startX, startY), (endX, endY), (255, 255, 255), 1)\n", + " y = startY - 10 if startY - 10 > 10 else startY + 10\n", + " cv2.putText(clone, str(label), (startX, y), cv2.FONT_HERSHEY_SIMPLEX, 0.45, (255, 255, 255), 1)\n", + " ax.imshow(clone, cmap='gray')\n", + " \n", + " def __call__(self, img):\n", + " pyramid = self.image_pyramid(img, scale=self.kwargs['PYR_SCALE'], minSize=self.kwargs['ROI_SIZE'])\n", + " rois, locs = self.get_rois_and_locs(pyramid)\n", + " if self.kwargs['VIZ_ROIS']:\n", + " self.visualize_rois(rois)\n", + " preds, labels = self.get_preds(rois, locs)\n", + " nms_labels = self.apply_nms(labels)\n", + " \n", + " if self.kwargs['VISUALIZE']:\n", + " self.visualize_preds(img, nms_labels)\n", + " \n", + " return nms_labels" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bf632d44", + "metadata": { + "execution": { + "iopub.execute_input": "2022-04-01T17:43:05.992169Z", + "iopub.status.busy": "2022-04-01T17:43:05.991490Z", + "iopub.status.idle": "2022-04-01T17:43:05.995449Z", + "shell.execute_reply": "2022-04-01T17:43:05.996010Z", + "shell.execute_reply.started": "2022-04-01T17:41:40.911708Z" + }, + "id": "bf632d44", + "papermill": { + "duration": 0.019499, + "end_time": "2022-04-01T17:43:05.996167", + "exception": false, + "start_time": "2022-04-01T17:43:05.976668", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "kwargs = dict(\n", + " PYR_SCALE=1.25,\n", + " WIN_STEP=7,\n", + " ROI_SIZE=(21, 21),\n", + " INPUT_SIZE=(28, 28),\n", + " VISUALIZE=True,\n", + " MIN_CONF=0.8,\n", + " VIZ_ROIS=True\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a1624499", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000, + "referenced_widgets": [ + "1f93ecac155345b1984c61f96ab87ff7", + "ad6794cbd18d4711afbd60ec386d9fc6", + "32502db341304ec689126e6585457702", + "4ee8b905c570423bb73a4459cac30b11", + "ef6474e57a64456582c906f9c36ccc77", + "a138e4f048b34bce90f2313b224c8c76", + "be9cc1242564461cae422ce8efd3078e", + "845da284dc7c44efa78e1c468f4ca033", + "e95080f564b44000a87b19ad90454b66", + "4b467b122d264b8fbdd9c3c7f3e6ed7a", + "4b50df5493004ca5a680f2bc043be20e", + "b82366b1a30d488395e6582345a22c5b", + "fa14d0190d454599bfbc40651494dbf1", + "1ffaed06eb4f4e56988fe4b1fe80492c", + "156327fda1ae467397c19a5ae14b609f", + "f445dddfb5e44bbfa9ad5425f5776651", + "a9a803859833429d8cc006a797627f85", + "fa1b050f67644cf186c1ddc81a656cb9", + "ce06b63d65b1462dbaa45f5011a80924", + "c921794206014f37b59f718fb85e7839", + "b5cf9413f30246f7ac92980f8ac3dced", + "56e895542db34b26ba8e235d3107487f", + "612d904da0894e49ac8a271e71774b57", + "3ca04ee7f34a455ba023b60785114047", + "169afd193f4f43c69145b253ea91d96e", + "4b99ac91415d4ac9a537ec3af8e3dffc", + "12150261ec044971a0e133cef160f313", + "741f46b0ef044f71a5ef6af92b826a1c", + "930751ee69eb4842820b32e76236857f", + "2784cf352acf46df8c9d74443ceece72", + "0787409a29cb4b80ae78a728402346ce", + "4c5b72d5c4634fcf8aad50aaade9e760", + "6d0e73728a61431790078bd5bd6cbb66", + "17b095df30e74b0fbf66069d5bbe7d10", + "6fc4a58dfc04484eaa31dd7038076602", + "8ddc71caa6134b8d94ba23e7047309a3", + "030202e5b3204ac2bcaf7265d131f7c4", + "66c58dc2e12f487397b80d18f1b8e735", + "3103018dc4f349569d539f2ab38ad387", + "af3b212f243e427298b446e7d6b5fab5", + "c1a33fb51bbc4e30a7bc41b86971c125", + "d67de551d9104a03b5dc966614be4fa7", + "dd6402e2014e4f38ad1ba25220d6d645", + "df4b5afc1aa744fdb9ea1d2abb1570dc", + "5e4cc745cde749d792e7b211873ff5c3", + "bc81cbfb5c334e10b26cb978cfe0aa9c", + "832a4dc4a54d444289519b59454d463a", + "25ca70b7ed104ecd867e0bc4ab76faa3", + "a0feef269de542ffbf3eb77516966f03", + "42b910c4e7664bf9accd340ac9fecf6d", + "8d8b47fc536e4ae787ed56caa73b4308", + "a2d50d43abf14b0295ea29b7498e162b", + "c12545c7337e4a88807aeac8e7f3b18a", + "f89c6751042b44448ecb3eb17759015a", + "c0125ecd37634a57a06a4d8f6d48aff1", + "95f275a437ae479786b065ef41ee5d16", + "c319645a5e1b489c8c42b24acba628d9", + "44086650a89648abb9221171480e276f", + "07a00011ba52425b91b684b31874fdf0", + "c7b378771bb4496f85a05730a781aa2a", + "fe659924680043db9a334010ecea7c0e", + "0abc9541bc6d4d79b0b91dfe625052fe", + "d3ec54dec4d6425294f10e016473a90e", + "6240bb9f9d4d497c94631b0526c740e6", + "abc369bfa2ce410a8871e13d510d4c52", + "5c895787b81846eab57e628235478030" + ] + }, + "execution": { + "iopub.execute_input": "2022-04-01T17:43:06.024209Z", + "iopub.status.busy": "2022-04-01T17:43:06.023594Z", + "iopub.status.idle": "2022-04-01T17:43:12.634753Z", + "shell.execute_reply": "2022-04-01T17:43:12.635280Z", + "shell.execute_reply.started": "2022-04-01T17:41:40.929206Z" + }, + "id": "a1624499", + "outputId": "555d1bc8-ca9c-49f7-f026-24dc2eb8c211", + "papermill": { + "duration": 6.627242, + "end_time": "2022-04-01T17:43:12.635456", + "exception": false, + "start_time": "2022-04-01T17:43:06.008214", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "config.json not found in HuggingFace Hub\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1f93ecac155345b1984c61f96ab87ff7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Downloading: 0%| | 0.00/1.29k [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Ritvik19/mnist-net is a convnet trained on mnist data read more: https://huggingface.co/Ritvik19/mnist-net\n", + "model = SlidingWindowObjectDetection('Ritvik19/mnist-net', **kwargs)\n", + "preds = model(orig)\n", + "print(\"Predictions: \", preds)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8b52a7e6", + "metadata": { + "id": "8b52a7e6", + "papermill": { + "duration": 0.017854, + "end_time": "2022-04-01T17:43:12.671513", + "exception": false, + "start_time": "2022-04-01T17:43:12.653659", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [], + "name": "Object Detection Sliding Window.ipynb", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.12" + }, + "papermill": { + "default_parameters": {}, + "duration": 39.563539, + "end_time": "2022-04-01T17:43:15.733024", + "environment_variables": {}, + "exception": null, + "input_path": "__notebook__.ipynb", + "output_path": "__notebook__.ipynb", + "parameters": {}, + "start_time": "2022-04-01T17:42:36.169485", + "version": "2.3.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}