95 Views

Optimalkan hasil Deteksi Objek dengan Non max suppression –  merupakan algoritma yang dikembangkan untuk menghasilkan solusi ketika hasil object detection yang overlapping. Cerita ini dimulai ketika saya bekerja untuk sebuah project yang melibatkan proses object detection menggunakan deep learning yaitu untuk menentukan lokasi plate number pada sebuah vendor parking management. Setelah melakukan urusan data enginer yang bertugas melakukan labeling satu-persatu menggunakan format PASCALVOC

Dilanjutkan dengan algoritma deep learning yang didalamnya menggunakan selective search, proses pelatihan cukup lama hampir 28 jam, ternyata hasilnya kurang memuaskan yaitu seperti berikut

Malah terdeteksi 2 objek yang saling overlapping, hal ini harus dicarikan solusi yaitu dari Tomasz (Tom) Malisiewicz, Ph.D yang didalamnya menggunakan matlab yaitu Non max suppression serta artikel dari pyimagesearch mengenai non max supression. Perhatikan gambar berikut

Optimalkan hasil Deteksi Objek dengan Non max suppression ketika saya terapkan maka hasilnya bagus seperti berikut

Cara kerja Optimalkan hasil Deteksi Objek dengan Non max suppression dengan melakukan operasi intersection, bila masih bingung, coba perhatikan ilustrasi berikut

Dengan menggunakan Non max suppression maka overlapping bisa dihindarkan! Bilamana ada 2 objek, maka tidak akan mempengaruhi hasilnya seperti berikut

Adapun untuk kode Non max suppression yang saya gunakan dari  PyImageSearch yaitu

# import the necessary packages
import numpy as np
#  Felzenszwalb et al.
def non_max_suppression(boxes, overlapThresh):
   # if there are no boxes, return an empty list
   if len(boxes) == 0:
      return []
   # initialize the list of picked indexes
   pick = []
   # grab the coordinates of the bounding boxes
   x1 = boxes[:,0]
   y1 = boxes[:,1]
   x2 = boxes[:,2]
   y2 = boxes[:,3]
   # compute the area of the bounding boxes and sort the bounding
   # boxes by the bottom-right y-coordinate of the bounding box
   area = (x2 - x1 + 1) * (y2 - y1 + 1)
   idxs = np.argsort(y2)
   # keep looping while some indexes still remain in the indexes
   # list
   while len(idxs) > 0:
      # grab the last index in the indexes list, add the index
      # value to the list of picked indexes, then initialize
      # the suppression list (i.e. indexes that will be deleted)
      # using the last index
      last = len(idxs) - 1
      i = idxs[last]
      pick.append(i)
      suppress = [last]
      # loop over all indexes in the indexes list
      for pos in range(0, last):
         # grab the current index
         j = idxs[pos]
         # find the largest (x, y) coordinates for the start of
         # the bounding box and the smallest (x, y) coordinates
         # for the end of the bounding box
         xx1 = max(x1[i], x1[j])
         yy1 = max(y1[i], y1[j])
         xx2 = min(x2[i], x2[j])
         yy2 = min(y2[i], y2[j])
         # compute the width and height of the bounding box
         w = max(0, xx2 - xx1 + 1)
         h = max(0, yy2 - yy1 + 1)
         # compute the ratio of overlap between the computed
         # bounding box and the bounding box in the area list
         overlap = float(w * h) / area[j]
         # if there is sufficient overlap, suppress the
         # current bounding box
         if overlap > overlapThresh:
            suppress.append(pos)
      # delete all indexes from the index list that are in the
      # suppression list
      idxs = np.delete(idxs, suppress)
   # return only the bounding boxes that were picked
   return boxes[pick]

Cara menggunakannya seperti berikut

import numpy as np
import cv2
from matplotlib import pyplot as plt
# https://www.pyimagesearch.com/2014/11/17/non-maximum-suppression-object-detection-python/
#https://github.com/rbgirshick/voc-dpm/blob/master/test/nms.m
# construct a list containing the images that will be examined
# along with their respective bounding boxes
images = [
   ("latihan/1.jpg", np.array([
   (12, 84, 140, 212),
   (24, 84, 152, 212),
   (36, 84, 164, 212),
   (12, 96, 140, 224),
   (24, 96, 152, 224),
   (24, 108, 152, 236)])),
   ("latihan/2.jpg", np.array([
   (114, 60, 178, 124),
   (120, 60, 184, 124),
   (114, 66, 178, 130)])),
   ("latihan/3.jpg", np.array([
   (12, 30, 76, 94),
   (12, 36, 76, 100),
   (72, 36, 200, 164),
   (84, 48, 212, 176)]))]
# loop over the images

i = 1
for (imagePath, boundingBoxes) in images:
    # load the image and clone it
    print ("[x] %d initial bounding boxes" % (len(boundingBoxes)))
    image = cv2.imread(imagePath)
    orig = image.copy()
    # loop over the bounding boxes for each image and draw them
    for (startX, startY, endX, endY) in boundingBoxes:
    	cv2.rectangle(orig, (startX, startY), (endX, endY), (0, 0, 255), 2)
    # perform non-maximum suppression on the bounding boxes
    pick = non_max_suppression(boundingBoxes, 0.3)
    print ("[x] after applying non-maximum, %d bounding boxes" % (len(pick)))
    # loop over the picked bounding boxes and draw them
    for (startX, startY, endX, endY) in pick:
    	cv2.rectangle(image, (startX, startY), (endX, endY), (0, 255, 0), 2)
    # display the images
    #cv2.imshow("Original", orig)
    #cv2.imshow("After NMS", image)
    plt.figure()
    plt.subplot(1,2,1),plt.imshow(orig),plt.title("asli")
    plt.subplot(1,2,2),plt.imshow(image),plt.title("NMS")
    plt.show()
    #cv2.waitKey(0)
    i = i+1

Kode diatas sangat membantu sekali dalam deep machine learning

 

Leave a Reply

Your email address will not be published. Required fields are marked *

3 + = 5