Object Detection Challenge
Create New

Object Detection Challenge



Object Detection Challenge
Object Detection Challenge

Project Rating

Overall Rating
0
0
0
0
0

Object detection is a computer vision task that involves both localizing one or more objects within an image and classifies each object in the image. It deals with detecting instances of semantic objects of a certain class (such as humans, buildings, or cars) in digital images and videos.

Why: Problem statement

It is a challenging problem that involves building upon methods for object recognition (e.g. where are they), object localization (e.g. what are their extent), and object classification (e.g. what are they). This also requires both successful object localization in order to locate and draw a bounding box around each object in an image, and object classification to predict the correct class of object that was localized.

How: Solution description

We present a conceptually simple, flexible, and general framework for object instance segmentation. Our approach efficiently detects objects in an image while simultaneously generating a high-quality segmentation mask for each instance. The method called Mask R-CNN, add a branch for predicting an object mask in parallel with the existing branch for bounding box recognition. The block diagram has shown bellow.

We can also use a pre-trained Mask R-CNN model to detect objects. The first step is to install the library. Download the weights for the pre-trained model, specifically a Mask R-CNN trained on the MS Coco dataset. Download the model weights to a file with the name ‘mask_rcnn_coco.h5‘ in your current working directory. First, the model must be defined via an instance MaskRCNN class.

This class requires a configuration object as a parameter. The configuration object defines how the model might be used during training or inference. In this case, the configuration will only specify the number of images per batch, which will be one, and the number of classes to predict. You can see the full extent of the configuration object and the properties that you can override in the config.py file.

We can now define the MaskRCNN instance. We will define the model as type “inference” indicating that we are interested in making predictions and not training. We must also specify a directory where any log messages could be written, which in this case will be the current working directory. The next step is to load the weights that we downloaded.

Now we can make a prediction for our image. First, we can load the image and convert it to a NumPy array. We can then make a prediction with the model. Instead of calling predict() as we would on a normal Keras model, will call the detect() function and pass it the single image. The result contains a dictionary for each image that we passed into the detect() function, in this case, a list of a single dictionary for the one image.

The dictionary has keys for the bounding boxes, masks, and so on, and each key points to a list for multiple possible objects detected in the image.

The keys of the dictionary of note are as follows:

  • rois‘: The bound boxes or regions-of-interest (ROI) for detected objects.

  • masks‘: The masks for the detected objects.

  • class_ids‘: The class integers for the detected objects.

  • scores‘: The probability or confidence for each predicted class.

We can draw each box detected in the image by first getting the dictionary for the first image (e.g. results[0]), and then retrieving the list of bounding boxes (e.g. [‘rois’]). Each bounding box is defined in terms of the bottom left and top right coordinates of the bounding box in the image. We can use these coordinates to create a Rectangle() from the matplotlib API and draw each rectangle over the top of our image. We can now tie all of this together and load the pre-trained model and use it to detect objects.

We can find the coordinates of each object by using the below code.

We use pillow and OpenCV library to detect the coordinates of the objects. First, it will divide our place into 4 equal parts and tell us the coordinates of the required object.

Inorder to pass this code to robotic arm, we have to make serial communication for object detection code with robotic arm. The serial communication code can be found below.

 

This code combines the object detection code with the robotic arm. Now, the robotic arm will pick and place the object according to the user instructions.

How is it different from competition

The Mask_RCNN API provides a function called display_instances() that will take the array of pixel values for the loaded image and the aspects of the prediction dictionary, such as the bounding boxes, scores, and class labels, and will plot the photo with all of these annotations.

One of the arguments is the list of predicted class identifiers available in the ‘class_ids‘ key of the dictionary. The function also needs a mapping of ids to class labels. 

The display_instances() function is flexible, allowing you to only draw the mask or only the bounding boxes.

Who are your customers

We can deploy this object detection into robots or we can use it through the web application. Object detection has applications in many areas of computer vision, including image retrieval and video surveillance.

Project Phases and Schedule

Phase 1: Collect Images

Phase 2: Build an AI model and train objects

Phase 3: Visualization and result

Resources Required

Anaconda

Python 3.7

Jupyter notebook

Download:
Project Code Code copy
/* Your file Name : demo.ipynb */
/* Your coding Language : python */
/* Your code snippet start here */
{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mask R-CNN Demo\n",
    "\n",
    "A quick intro to using the pre-trained model to detect and segment objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import random\n",
    "import math\n",
    "import numpy as np\n",
    "import skimage.io\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Root directory of the project  \n",
    "ROOT_DIR = os.path.abspath(\"../\")\n",
    "\n",
    "# Import Mask RCNN\n",
    "sys.path.append(ROOT_DIR)  # To find local version of the library\n",
    "from mrcnn import utils\n",
    "import mrcnn.model as modellib\n",
    "from mrcnn import visualize\n",
    "# Import COCO config\n",
    "sys.path.append(os.path.join(ROOT_DIR, \"samples/coco/\"))  # To find local version\n",
    "import coco\n",
    "\n",
    "%matplotlib inline \n",
    "\n",
    "# Directory to save logs and trained model\n",
    "MODEL_DIR = os.path.join(ROOT_DIR, \"logs\")\n",
    "\n",
    "# Local path to trained weights file\n",
    "COCO_MODEL_PATH = os.path.join(ROOT_DIR, \"mask_rcnn_coco.h5\")\n",
    "# Download COCO trained weights from Releases if needed\n",
    "if not os.path.exists(COCO_MODEL_PATH):\n",
    "    utils.download_trained_weights(COCO_MODEL_PATH)\n",
    "\n",
    "# Directory of images to run detection on\n",
    "IMAGE_DIR = os.path.join(ROOT_DIR, \"images\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "img = Image.open('img1.jpg') # image extension *.png,*.jpg\n",
    "new_width  = 650\n",
    "new_height = 480\n",
    "img = img.resize((new_width, new_height), Image.ANTIALIAS)\n",
    "img.save('img2.jpg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from flask import request\n",
    "from flask import jsonify\n",
    "from flask import Flask\n",
    "from keras.models import load_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import logging\n",
    "import argparse\n",
    "\n",
    "# Import flask libraries\n",
    "import hashlib\n",
    "import json\n",
    "from time import time\n",
    "from urllib.parse import urlparse\n",
    "from uuid import uuid4\n",
    "\n",
    "import requests\n",
    "from flask import Flask, jsonify, request"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mrcnn.visualize import display_images\n",
    "from mrcnn.model import log"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configurations\n",
    "\n",
    "We'll be using a model trained on the MS-COCO dataset. The configurations of this model are in the ```CocoConfig``` class in ```coco.py```.\n",
    "\n",
    "For inferencing, modify the configurations a bit to fit the task. To do so, sub-class the ```CocoConfig``` class and override the attributes you need to change."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Configurations:\n",
      "BACKBONE                       resnet101\n",
      "BACKBONE_STRIDES               [4, 8, 16, 32, 64]\n",
      "BATCH_SIZE                     1\n",
      "BBOX_STD_DEV                   [0.1 0.1 0.2 0.2]\n",
      "COMPUTE_BACKBONE_SHAPE         None\n",
      "DETECTION_MAX_INSTANCES        100\n",
      "DETECTION_MIN_CONFIDENCE       0.7\n",
      "DETECTION_NMS_THRESHOLD        0.3\n",
      "FPN_CLASSIF_FC_LAYERS_SIZE     1024\n",
      "GPU_COUNT                      1\n",
      "GRADIENT_CLIP_NORM             5.0\n",
      "IMAGES_PER_GPU                 1\n",
      "IMAGE_MAX_DIM                  1024\n",
      "IMAGE_META_SIZE                93\n",
      "IMAGE_MIN_DIM                  800\n",
      "IMAGE_MIN_SCALE                0\n",
      "IMAGE_RESIZE_MODE              square\n",
      "IMAGE_SHAPE                    [1024 1024    3]\n",
      "LEARNING_MOMENTUM              0.9\n",
      "LEARNING_RATE                  0.001\n",
      "LOSS_WEIGHTS                   {'rpn_class_loss': 1.0, 'rpn_bbox_loss': 1.0, 'mrcnn_class_loss': 1.0, 'mrcnn_bbox_loss': 1.0, 'mrcnn_mask_loss': 1.0}\n",
      "MASK_POOL_SIZE                 14\n",
      "MASK_SHAPE                     [28, 28]\n",
      "MAX_GT_INSTANCES               100\n",
      "MEAN_PIXEL                     [123.7 116.8 103.9]\n",
      "MINI_MASK_SHAPE                (56, 56)\n",
      "NAME                           coco\n",
      "NUM_CLASSES                    81\n",
      "POOL_SIZE                      7\n",
      "POST_NMS_ROIS_INFERENCE        1000\n",
      "POST_NMS_ROIS_TRAINING         2000\n",
      "ROI_POSITIVE_RATIO             0.33\n",
      "RPN_ANCHOR_RATIOS              [0.5, 1, 2]\n",
      "RPN_ANCHOR_SCALES              (32, 64, 128, 256, 512)\n",
      "RPN_ANCHOR_STRIDE              1\n",
      "RPN_BBOX_STD_DEV               [0.1 0.1 0.2 0.2]\n",
      "RPN_NMS_THRESHOLD              0.7\n",
      "RPN_TRAIN_ANCHORS_PER_IMAGE    256\n",
      "STEPS_PER_EPOCH                1000\n",
      "TOP_DOWN_PYRAMID_SIZE          256\n",
      "TRAIN_BN                       False\n",
      "TRAIN_ROIS_PER_IMAGE           200\n",
      "USE_MINI_MASK                  True\n",
      "USE_RPN_ROIS                   True\n",
      "VALIDATION_STEPS               50\n",
      "WEIGHT_DECAY                   0.0001\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "class InferenceConfig(coco.CocoConfig):\n",
    "    # Set batch size to 1 since we'll be running inference on\n",
    "    # one image at a time. Batch size = GPU_COUNT * IMAGES_PER_GPU\n",
    "    GPU_COUNT = 1\n",
    "    IMAGES_PER_GPU = 1\n",
    "\n",
    "config = InferenceConfig()\n",
    "config.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create Model and Load Trained Weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /anaconda3/lib/python3.6/site-packages/tensorflow/python/framework/op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n",
      "WARNING:tensorflow:From /anaconda3/lib/python3.6/site-packages/mrcnn/model.py:775: to_float (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.cast instead.\n"
     ]
    }
   ],
   "source": [
    "# Create model object in inference mode.\n",
    "model = modellib.MaskRCNN(mode=\"inference\", model_dir=MODEL_DIR, config=config)\n",
    "\n",
    "# Load weights trained on MS-COCO\n",
    "model.load_weights(COCO_MODEL_PATH, by_name=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class Names\n",
    "\n",
    "The model classifies objects and returns class IDs, which are integer value that identify each class. Some datasets assign integer values to their classes and some don't. For example, in the MS-COCO dataset, the 'person' class is 1 and 'teddy bear' is 88. The IDs are often sequential, but not always. The COCO dataset, for example, has classes associated with class IDs 70 and 72, but not 71.\n",
    "\n",
    "To improve consistency, and to support training on data from multiple sources at the same time, our ```Dataset``` class assigns it's own sequential integer IDs to each class. For example, if you load the COCO dataset using our ```Dataset``` class, the 'person' class would get class ID = 1 (just like COCO) and the 'teddy bear' class is 78 (different from COCO). Keep that in mind when mapping class IDs to class names.\n",
    "\n",
    "To get the list of class names, you'd load the dataset and then use the ```class_names``` property like this.\n",
    "```\n",
    "# Load COCO dataset\n",
    "dataset = coco.CocoDataset()\n",
    "dataset.load_coco(COCO_DIR, \"train\")\n",
    "dataset.prepare()\n",
    "\n",
    "# Print class names\n",
    "print(dataset.class_names)\n",
    "```\n",
    "\n",
    "We don't want to require you to download the COCO dataset just to run this demo, so we're including the list of class names below. The index of the class name in the list represent its ID (first class is 0, second is 1, third is 2, ...etc.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# COCO Class names\n",
    "# Index of the class in the list is its ID. For example, to get ID of\n",
    "# the teddy bear class, use: class_names.index('teddy bear')\n",
    "class_names = ['BG', 'person', 'bicycle', 'car', 'motorcycle', 'airplane',\n",
    "               'bus', 'train', 'truck', 'boat', 'traffic light',\n",
    "               'fire hydrant', 'stop sign', 'parking meter', 'bench', 'bird',\n",
    "               'cat', 'dog', 'horse', 'sheep', 'cow', 'elephant', 'bear',\n",
    "               'zebra', 'giraffe', 'backpack', 'umbrella', 'handbag', 'tie',\n",
    "               'suitcase', 'frisbee', 'skis', 'snowboard', 'sports ball',\n",
    "               'kite', 'baseball bat', 'baseball glove', 'skateboard',\n",
    "               'surfboard', 'tennis racket', 'bottle', 'wine glass', 'cup',\n",
    "               'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple',\n",
    "               'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza',\n",
    "               'donut', 'cake', 'chair', 'couch', 'potted plant', 'bed',\n",
    "               'dining table', 'toilet', 'tv', 'laptop', 'mouse', 'remote',\n",
    "               'keyboard', 'cell_phone', 'microwave', 'oven', 'toaster',\n",
    "               'sink', 'refrigerator', 'book', 'clock', 'vase', 'scissor',\n",
    "               'teddy bear', 'hair drier', 'spoon']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['BG', 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train', 'truck', 'boat', 'traffic light', 'fire hydrant', 'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat', 'baseball glove', 'skateboard', 'surfboard', 'tennis racket', 'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair', 'couch', 'potted plant', 'bed', 'dining table', 'toilet', 'tv', 'laptop', 'mouse', 'remote', 'keyboard', 'cell_phone', 'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase', 'scissor', 'teddy bear', 'hair drier', 'marker']\n"
     ]
    }
   ],
   "source": [
    "print(class_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run Object Detection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing 1 images\n",
      "image                    shape: (480, 650, 3)         min:    0.00000  max:  255.00000  uint8\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.6/site-packages/skimage/transform/_warps.py:110: UserWarning: Anti-aliasing will be enabled by default in skimage 0.15 to avoid aliasing artifacts when down-sampling images.\n",
      "  warn(\"Anti-aliasing will be enabled by default in skimage 0.15 to \"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "molded_images            shape: (1, 1024, 1024, 3)    min: -123.70000  max:  151.10000  float64\n",
      "image_metas              shape: (1, 93)               min:    0.00000  max: 1024.00000  float64\n",
      "anchors                  shape: (1, 261888, 4)        min:   -0.35390  max:    1.29134  float32\n"
     ]
    },
    {
     "data": {
      "image/png": "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