Perhitungan Deteksi Objek pada Gambar dan Video dengan YOLOv4 (Counting Objects)

5 min readDec 22, 2020

Selamat liburan akhir tahun teman-teman semua. Sekarang kita lanjut lagi pembahasan algoritma deep learning YOLO yang sudah masuk ke part 12. Main Goal dari YOLOv4 adalah peningkatan yang sangat signifikan dalam hal kecepatan dan performance. Dari hasil pendeteksian dan tingkat akurasi yang tinggi menjadikan YOLO sebagai algoritma object detection terbaik.

Setelah kita mencoba mendeteksi object dengan dataset yang sudah disediakan COCO dataset, maupun sudah bisa membuat custom object detection yang sudah kita training dan testing. Sekarang kita akan mencoba melakukan beberapa fungsi lainnya dengan YOLOv4 ini, salah satunya adalah menghitung objek yang terdeteksi. Implementasi perhitungan objek ini bisa dikembangkan dalam pembuatan aplikasi perhitungan kendaraan, jumlah orang yang melewati jalan raya dll.

Kita akan coba mengimplementasikannya dengan Tensorflow, YOLOv4 dan beberapa library Python. Pastikan pada folder repo project yang ingin kita buat sudah ada file cfg dan weights, bisa di download disini. Berikut ini adalah library dan framework yang diugnakan. Pada framework tensorflow kita mengimport ConfigProto untuk pengaturan alokasi GPU. Opsi konfigurasi dengan menggunakan config.gpu_options.allow_growth = True membuat proses alokasi memori pada GPU dengan penggunaan lebih dari user bisa lebih terdistribusi dengan baik sehingga tidak menyebabkan memori dari GPU dialokasikan sepenuhnya dari proses object detection.

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
import tensorflow as tf
physical_devices = tf.config.experimental.list_physical_devices('GPU')
if len(physical_devices) > 0:
tf.config.experimental.set_memory_growth(physical_devices[0], True)
from absl import app, flags, logging
from absl.flags import FLAGS
import core.utils as utils
from core.yolov4 import filter_boxes
from core.functions import *
from tensorflow.python.saved_model import tag_constants
from PIL import Image
import cv2
import numpy as np
from tensorflow.compat.v1 import ConfigProto
from tensorflow.compat.v1 import InteractiveSessiondef main(_argv):
config = ConfigProto()
config.gpu_options.allow_growth = True
session = InteractiveSession(config=config)

Pengaturan selanjutnya yang harus di setting adalah bagaimana hanya menampilkan object-object dengan akurasi yang terbaik. Sudah dijelaskan juga di part sebelumnya, dengan menggunakan non max suppresion nantinya akan menghilangkan bounding box dengan skor kepercayaan yang rendah. Ambang batas dari skor kepercayaan bisa diatur dengan range angka 0–1. Disini kita akan memberikan value threshold iou = 0.45 dan threshold score sebesar 0.50

boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression(
    boxes=tf.reshape(boxes, (tf.shape(boxes)[0], -1, 1, 4)),
    scores=tf.reshape(
    pred_conf, (tf.shape(pred_conf)[0], -1, 
    tf.shape(pred_conf)[-1])),
    max_output_size_per_class=50,
    max_total_size=50,
    iou_threshold=0.45,
    score_threshold=0.50
)

Kemudian kita buat sebuah function untuk format bounding box. Titik koordinat sumbu dalam setiap bounding box akan dicatat dengan dimasukkan ke varibael xmin, ymin, xmax dan ymax.

def format_boxes(bboxes, image_height, image_width):
for box in bboxes:
ymin = int(box[0] * image_height)
xmin = int(box[1] * image_width)
ymax = int(box[2] * image_height)
xmax = int(box[3] * image_width)
box[0], box[1], box[2], box[3] = xmin, ymin, xmax, ymax
return bboxes

Buat sebuah variabel untuk menyimpan nilai nama-nama object yang bisa dideteksi. Secara default, YOLOv4 memakai dataset dari coco sehingga kita bisa memanggil semua value di file coco.names

class_names = utils.read_class_names("./classes/coco.names")
allowed_classes = list(class_names.values())

Setelah kita sudah tentukan titik kordinat untuk bounding box, kemudia nkita buat sebuah fungsi untuk draw bounding box. Hasil yang kita inginkan adalah sebuah bounding box dengan tambahan label objek yang terdeteksi dan score akurasi dengan persen. Variabel colors merupakan sebuah list untuk menyimpan warna-warna yang akan digunakan setiap bounding box. Kemudian kita akan menggunakan python random number generator yaitu library random. random.seed(0) adalah sebuah method untuk mengenerate angka dengan proses distribusi yang sama (pseudo-random). Dengan value seed yang sama, maka akan menghasilkan urutan(sequence) angka yang sama. Sedangkan random.shuffle adalah proses pengacakan urutan indeks dari sebuah array/list. Maka variabel colors akan diacak setiap value colournya sehingga akan mendapatkan nilai RGB secara random. Intinya adalah setiap objek yang terdeteksi akan membentuk warna bounding box yang berbeda-beda yang didapat secara acak, tetapi dengan objek yang sama (misal ada 2 person) akan terbentuk bounding box person dengan warna yang sama.

def draw_bbox(image, bboxes, info = False, counted_classes = None, show_label=True, allowed_classes=list(read_class_names(cfg.YOLO.CLASSES).values()), read_plate = False):classes = read_class_names(cfg.YOLO.CLASSES)
num_classes = len(classes)
image_h, image_w, _ = image.shape
hsv_tuples = [(1.0 * x / num_classes, 1., 1.) for x in range(num_classes)]colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))colors = list(map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)), colors))random.seed(0)
random.shuffle(colors)
random.seed(None)
out_boxes, out_scores, out_classes, num_boxes = bboxes

Kemudian script selanjutnya adalah pengaturan warna bounding box, ketebalan bounding box dan tata letak/posisi dari bounding box dan label yang akan ditampilkan. Dengan syntax dari OpenCV (cv2.rectangle()), maka setiap objek akan dideteksi dengan kotak pembatas dengan tambahan label nama class dan score predictionnya.

bbox_color = colors[class_ind]
bbox_thick = int(0.6 * (image_h + image_w) / 600)
c1, c2 = (coor[0], coor[1]), (coor[2], coor[3])
cv2.rectangle(image, c1, c2, bbox_color, bbox_thick)

Kemudian kita bisa membuat sebuah script yang sederhana untuk count object yang terdeteksi. Awalnya dalam variabel data kita mendapatkan value dari boxes, scores, classes dan num_objects yang didapat dari running non max suppression. Dari situ kita bisa mendapatkan jumlah object yang terdeteksi dalam satu frame proses. Jika class_name termasuk dalam allowed_classes(termasuk class yang ada di coco.names) maka hitung jumlah class_names objek tersebut dengan ditambah 1.

boxes, scores, classes, num_objects = datacounts = dict()
class_names = read_class_names(cfg.YOLO.CLASSES)for i in range(num_objects):class_index = int(classes[i])
class_name = class_names[class_index]
if class_name in allowed_classes:
     counts[class_name] = counts.get(class_name, 0) + 1
else:
     continue
else:
     counts['total object'] = num_objectsreturn counts

Kemudian kita akan tampilkan hasil perhitungan objek dengan memberikan sebuah label text diatas pojok kiri atas frame gambar/videonya. Kita bisa menggunakan perintah opencv yaitu cv2.putText dengan menampilkan objek yang terdeteksi dan jumlahnya.

height_ratio = int(image_h / 25)
offset = 15
for key, value in counted_classes.items():cv2.putText(image, "{}s detected: {}".format(key, value), (5, offset),cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 0, 255), 2)offset += height_ratio

Demikianlah sedikit script yang digunakan untuk menghitung sebuah objek dengan YOLOv4 dan bantuan framework Tensorflow dan Keras. Kalian bisa akses full code disini.

Next time mungkin kita akan mencoba menggunakan YOLOv4 dengan framework Darknet yaitu dengan bahasa pemrograman C. Pendapatku dengan kondisi spesifikasi laptop yang ku gunakan, lebih cepat dan akurat jika menggunakan darknet dibandingkan Tensorflow/Darkflow dengan bahasa pemrograman Python.

Full Stories :

Sumber :

Perhitungan Deteksi Objek pada Gambar dan Video dengan YOLOv4 (Counting Objects)

Written by Haiqal Muhamad Alfarisi

No responses yet