DEV Community: raven

Object Detection Using Tensorflow

raven — Thu, 10 Dec 2020 16:52:15 +0000

Object Detection using Tensorflow is a computer vision technique. As the name suggests, it helps us in detecting, locating, and tracing an object from an image or camera.

What is Object detection?
Object detection is a computer vision technique in which a software system can detect, locate, and trace the object from a given image or video. The special attribute about object detection is that it identifies the class of object (person, table, chair, etc.) and their location-specific coordinates in the given image. The location is pointed out by drawing a bounding box around the object. The bounding box may or may not accurately locate the position of the object. The ability to locate the object inside an image defines the performance of the algorithm used for detection. Face detection is one of the examples of object detection.

How does Object detection work?
Generally, the object detection task is carried out in three steps:

Generates the small segments in the input as shown in the image below. As you can see the large set of bounding boxes are spanning the full image
Feature extraction is carried out for each segmented rectangular area to predict whether the rectangle contains a valid object.
Overlapping boxes are combined into a single bounding rectangle (Non-Maximum Suppression)

What is TensorFlow?
Tensorflow is an open-source library for numerical computation and large-scale machine learning that ease Google Brain TensorFlow, the process of acquiring data, training models, serving predictions, and refining future results.

Tensorflow bundles together Machine Learning and Deep Learning models and algorithms. It uses Python as a convenient front-end and runs it efficiently in optimized C++.

Object Detection Using Tensorflow
As mentioned above the knowledge of neural network and machine learning is not mandatory for using this API as we are mostly going to use the files provided in the API. All we need is some knowledge of python and passion for completing this project.
Follow the below-mentioned steps :
Step 1: Create a folder named ObjectDetection and open it with the VS Code.
Step 2: Download Tensorflow API from Github Repository by typing the below-mentioned command in vs code's terminal

git clone https://github.com/tensorflow/models

step 3: Setting up a virtual environment

python -m venv --system-site-packages .\venv

activate the environment

.\venv\Scripts\activate

upgrading pip version to the latest

python -m pip install --upgrade --ignore-installed

Step 4: Installing dependencies

Installing and upgrading tensorflow pip install tensorflow

pip install --upgrade tensorflow

installing matplotlib

pip install pillow Cython lxml jupyter matplotlib

Navigate to the research subfolder in the models folder.

cd \models\research\

Step 5: Now we need to download Protocol Buffers (Protobuf) which are Google’s language-neutral, platform-neutral, extensible mechanism for serializing structured data, – think of it as XML, but smaller, faster, and simpler.

Extract the content of the downloaded zip from the above link in the research subfolder of the models' folder and visit the bin folder and copy the path of the protoc.exe there.
Then open "Edit the system environment variables" and click on "Environment Variables".

(i) Under system variables select 'path' and click on edit.
(ii)Click on New and paste the copied path of the 'protoc.exe'.
Step 6: Then in the terminal of vs code run this command

protoc object_detection/protos/*.proto --python_out=.

Step 7: Create a new python file named 'detect.py' in the same folder and paste the code given below :

import numpy as np
import os
import six.moves.urllib as urllib
import sys
import tarfile
import tensorflow as tf
import zipfile
import pathlib
from collections import defaultdict
from io import StringIO
from matplotlib import pyplot as plt
from PIL import Image
from IPython.display import display
from object_detection.utils import ops as utils_ops
from object_detection.utils import label_map_util
from object_detection.utils import visualization_utils as vis_util

while "models" in pathlib.Path.cwd().parts:
    os.chdir('..')

def load_model(model_name):
  base_url = 'http://download.tensorflow.org/models/object_detection/'
  model_file = model_name + '.tar.gz'
  model_dir = tf.keras.utils.get_file(
    fname=model_name, 
    origin=base_url + model_file,
    untar=True)

  model_dir = pathlib.Path(model_dir)/"saved_model"
  model = tf.saved_model.load(str(model_dir))
  return model

PATH_TO_LABELS = 'models/research/object_detection/data/mscoco_label_map.pbtxt'
category_index = label_map_util.create_category_index_from_labelmap(PATH_TO_LABELS, use_display_name=True)

model_name = 'ssd_inception_v2_coco_2017_11_17'
detection_model = load_model(model_name)

def run_inference_for_single_image(model, image):
  image = np.asarray(image)
  # The input needs to be a tensor, convert it using `tf.convert_to_tensor`.
  input_tensor = tf.convert_to_tensor(image)
  # The model expects a batch of images, so add an axis with `tf.newaxis`.
  input_tensor = input_tensor[tf.newaxis,...]

  # Run inference
  model_fn = model.signatures['serving_default']
  output_dict = model_fn(input_tensor)

  # All outputs are batches tensors.
  # Convert to numpy arrays, and take index [0] to remove the batch dimension.
  # We're only interested in the first num_detections.
  num_detections = int(output_dict.pop('num_detections'))
  output_dict = {key:value[0, :num_detections].numpy() 
                 for key,value in output_dict.items()}
  output_dict['num_detections'] = num_detections

  # detection_classes should be ints.
  output_dict['detection_classes'] = output_dict['detection_classes'].astype(np.int64)

  # Handle models with masks:
  if 'detection_masks' in output_dict:
    # Reframe the the bbox mask to the image size.
    detection_masks_reframed = utils_ops.reframe_box_masks_to_image_masks(
              output_dict['detection_masks'], output_dict['detection_boxes'],
               image.shape[0], image.shape[1])      
    detection_masks_reframed = tf.cast(detection_masks_reframed > 0.5,
                                       tf.uint8)
    output_dict['detection_masks_reframed'] = detection_masks_reframed.numpy()

  return output_dict

def show_inference(model, frame):
  #take the frame from webcam feed and convert that to array
  image_np = np.array(frame)
  # Actual detection.

  output_dict = run_inference_for_single_image(model, image_np)
  # Visualization of the results of a detection.
  vis_util.visualize_boxes_and_labels_on_image_array(
      image_np,
      output_dict['detection_boxes'],
      output_dict['detection_classes'],
      output_dict['detection_scores'],
      category_index,
      instance_masks=output_dict.get('detection_masks_reframed', None),
      use_normalized_coordinates=True,
      line_thickness=5)

  return(image_np)

#Now we open the webcam and start detecting objects
import cv2
video_capture = cv2.VideoCapture(0)
while True:
    # Capture frame-by-frame
    re,frame = video_capture.read()
    Imagenp=show_inference(detection_model, frame)
    cv2.imshow('object detection', cv2.resize(Imagenp, (800,600)))
    if cv2.waitKey(1) &amp; 0xFF == ord('q'):
        break
video_capture.release()
cv2.destroyAllWindows()

Step 7:For real-time object detection we need one more dependency OpenCV.So to install OpenCV run this command in terminal.

pip install opencv-python

Step 8: Now we are all done and our setup is ready to be executed and detect the objects. Execute the 'detect.py'

python detect.py

Managing multiple GitHub account using git in windows

raven — Thu, 04 Jun 2020 15:07:28 +0000

Wanna use another GitHub account in my windows pc but wait I already got my personal account added in git.
No problem here you can see how you can manage multiple accounts without any hassle:

Note: This DIY is meant for windows users.

Contents

*Set up SSH Keys.
*Add the keys to your Github accounts:
*Create a configuration file to manage the separate keys
*Update stored identities
*Test PUSH
*Test PULL

Set up SSH Keys

So let's consider your two GitHub accounts are named githubPersonal and githubWork, respectively.

Create two SSH keys, saving each to a separate file:
Execute the below mentioned commands in gitbash

$ cd ~/.ssh

$ ssh-keygen -t rsa -C "your_email_id_associated_with_githubPersonal_account

save it as id_rsa_personal when prompted (you can rename personal)
$ Enter passphrase (empty for no passphrase): skip this by pressing enter
$ Enter same passphrase again: skip this by pressing enter

$ ssh-keygen -t rsa -C "your_email_id_associated_with_githubWork_account"

save it as id_rsa_work when prompted (you can rename personal)
$ Enter passphrase (empty for no passphrase): skip this by pressing enter
$ Enter same passphrase again: skip this by pressing enter

The above commands setup the following files:
id_rsa_personal
id_rsa_personal.pub
id_rsa_work
id_rsa_work.pub

Add the keys to your Github accounts:

Copy the key to your clipboard by opening the file in vs code:

$ code . id_rsa_personal.pub

Add the key to your account:
Go to your GitHub Account Settings
Click “SSH Keys” then “Add SSH key”
Paste your key into the “Key” field and add a relevant title
Click “Add key” then enter your GitHub password to confirm.

Repeat the process for your githubWork account.

Create a configuration file

Create a configuration file to manage the separate keys in ~/.ssh/ using
$ touch config

Edit the file using the text editor of your choice. I used vs code -
$ code . config

# githubPersonal
Host personal
   HostName github.com
   User git
   IdentityFile ~/.ssh/id_rsa_personal

# githubWork
Host work
   HostName github.com
   User git
   IdentityFile ~/.ssh/id_rsa_work

Update stored identities

initialize the ssh-agent (use powershell)

Get-Service -Name ssh-agent | Set-Service -StartupType Manual

Clear currently stored identities:
$ ssh-add -D
Add new keys:

$ ssh-add id_rsa_personal

$ ssh-add id_rsa_work

Test to make sure new keys are stored:

$ ssh-add -l

Test to make sure Github recognizes the keys:

$ ssh -T personal

Hi githubPersonal! You've successfully authenticated, but GitHub does not provide shell access.

$ ssh -T work

Hi githubWork! You've successfully authenticated, but GitHub does not provide shell access.

Test PUSH

On Github, create a new repo in your personal account, githubPersonal, called test-personal.
Back on your local machine, create a test directory:
$ cd ~/documents
$ mkdir test-personal
$ cd test-personal
Add a blank “readme.md” file and PUSH to Github:
$ touch readme.md
$ git init
$ git add .
$ git commit -am "first commit"
$ git remote add origin git@personal:githubPersonal/test-personal.git
$ git push origin master
Notice how we’re using the custom account, git@personal, instead of git@github.com.

Repeat the process for your githubWork account.