Deteksi Objek dengan YOLO: Panduan Lengkap Arsitektur & Implementasi

Deteksi objek telah menjadi salah satu pilar utama dalam bidang computer vision, memungkinkan komputer untuk “melihat” dan mengidentifikasi objek dalam gambar atau video. Berbeda dengan klasifikasi gambar yang hanya menentukan kategori gambar secara keseluruhan, deteksi objek mampu melokalisasi dan mengidentifikasi berbagai objek sekaligus dalam satu gambar. Berbagai algoritma deteksi objek telah dikembangkan, dan salah satu yang paling terkenal adalah YOLO (object detection algorithms).

1. Apa itu Deteksi Objek dan Mengapa YOLO?

YOLO, singkatan dari “You Only Look Once”, adalah algoritma deteksi objek yang revolusioner karena kecepatan dan akurasinya. Tidak seperti algoritma lain yang memproses gambar berkali-kali untuk mendeteksi objek, YOLO hanya memerlukan satu kali pemrosesan (real-time object detection). Inilah yang membuatnya sangat cepat dan efisien. Algoritma deteksi objek YOLO (YOLO object detection) ini mampu mendeteksi berbagai objek dalam gambar secara real-time, membuatnya ideal untuk aplikasi yang membutuhkan respon cepat.

Keunggulan utama YOLO adalah kemampuannya untuk memproses gambar dengan frame rate tinggi, seringkali mencapai puluhan atau bahkan ratusan frame per second (FPS). Hal ini menjadikannya pilihan yang sangat baik untuk aplikasi seperti:

• Kendaraan otonom: Mendeteksi pejalan kaki, kendaraan lain, rambu lalu lintas, dan objek di sekitar mobil secara real-time.
• Robotika: Memungkinkan robot untuk mengenali dan berinteraksi dengan objek di lingkungannya.
• Analisis video pengawasan: Mendeteksi orang, aktivitas mencurigakan, atau objek tertentu dalam rekaman CCTV.
• Pemantauan industri: Mendeteksi cacat produk, memantau pergerakan barang, atau memastikan keamanan pekerja.
• Dan banyak aplikasi lainnya yang memerlukan pemahaman visual yang cepat dan akurat.

2. Arsitektur YOLO: Membedah Komponen Utama

Arsitektur YOLO (arsitektur YOLO) dirancang untuk efisiensi dan kecepatan. Secara garis besar, YOLO terdiri dari tiga komponen utama: backbone, neck, dan head.

2.1. Backbone

Backbone YOLO (backbone YOLO) berfungsi sebagai feature extractor. Bagian ini bertugas mengambil fitur-fitur penting dari gambar input. Biasanya, backbone ini berupa jaringan saraf konvolusional (CNN) yang telah dilatih sebelumnya (pre-trained) pada dataset besar seperti ImageNet. Beberapa contoh arsitektur backbone yang sering digunakan adalah:

Baca juga: Panduan Lengkap Convolutional Neural Networks (CNN) untuk Pemula

• Darknet: Arsitektur asli yang dikembangkan khusus untuk YOLO.
• CSPDarknet: Varian Darknet yang lebih efisien dan sering digunakan pada versi YOLO yang lebih baru.
• ResNet: Jaringan saraf yang populer dan terbukti efektif dalam berbagai tugas computer vision.
• EfficientNet: Keluarga arsitektur yang dirancang untuk mencapai keseimbangan optimal antara akurasi dan efisiensi komputasi.

2.2. Neck

Neck YOLO (neck YOLO) berperan sebagai jembatan antara backbone dan head. Bagian ini mengumpulkan dan menggabungkan fitur-fitur dari berbagai tingkatan (layer) backbone. Tujuannya adalah untuk memperkaya informasi fitur sebelum diteruskan ke head. Beberapa arsitektur neck yang umum digunakan adalah:

• Feature Pyramid Network (FPN): Membangun piramida fitur dari berbagai skala untuk mendeteksi objek dengan ukuran yang bervariasi.
• Path Aggregation Network (PAN): Mirip dengan FPN, tetapi menambahkan jalur (path) tambahan untuk memperkuat informasi fitur dari berbagai tingkatan.
• BiFPN: Varian FPN yang lebih efisien dengan koneksi bidirectional (dua arah).

2.3. Head

Head YOLO (head YOLO) adalah bagian yang bertanggung jawab untuk menghasilkan prediksi akhir. Head menerima input dari neck dan menghasilkan tiga jenis output:

• Bounding boxes: Kotak yang melingkupi objek yang terdeteksi. Setiap bounding box direpresentasikan oleh koordinat (x, y, lebar, tinggi).
• Class probabilities: Probabilitas untuk setiap kelas objek. Misalnya, jika model dilatih untuk mendeteksi 10 kelas objek, maka setiap bounding box akan memiliki 10 nilai probabilitas yang menunjukkan seberapa yakin model bahwa objek tersebut termasuk dalam kelas tertentu.
• Objectness score: Skor yang menunjukkan seberapa yakin model bahwa bounding box tersebut benar-benar berisi objek (bukan background).

Pada bagian head inilah loss function YOLO (YOLO loss function) berperan penting. Loss function ini mengukur perbedaan antara prediksi model dan ground truth (label yang sebenarnya). Selama proses pelatihan, model akan berusaha meminimalkan nilai loss ini, sehingga prediksinya semakin akurat. Loss Function pada YOLO merupakan gabungan dari:

• Loss Koordinat Bounding Box: Mengukur seberapa akurat posisi dan ukuran bounding box yang diprediksi.
• Loss Keyakinan (Objectness): Mengukur seberapa yakin model bahwa sebuah kotak berisi objek.
• Loss Klasifikasi: Mengukur seberapa tepat kelas objek yang diprediksi.

Karena dalam sebuah gambar sering kali terdapat banyak bounding box yang tumpang tindih, YOLO menggunakan teknik Non-Maximum Suppression (non-maximum suppression YOLO) untuk memilih bounding box yang paling tepat. Teknik ini bekerja dengan cara:

1. Memilih bounding box dengan skor objectness tertinggi.
2. Menghapus semua bounding box lain yang memiliki overlap (tumpang tindih) yang signifikan dengan bounding box yang dipilih. Pengukuran overlap biasanya menggunakan metrik Intersection over Union (IoU).
3. Mengulangi proses ini hingga semua bounding box yang tersisa tidak memiliki overlap yang signifikan.

2.4. Alur Kerja YOLO: Proses Lengkap

Secara ringkas, alur kerja YOLO adalah sebagai berikut:

1. Input: Gambar dimasukkan ke dalam jaringan.
2. Backbone: Backbone mengekstrak fitur-fitur penting dari gambar.
3. Neck: Neck mengumpulkan dan menggabungkan fitur-fitur dari berbagai tingkatan backbone.
4. Head: Head menghasilkan prediksi bounding boxes, class probabilities, dan objectness scores.
5. Non-Maximum Suppression: Bounding box yang tumpang tindih difilter untuk menghasilkan prediksi akhir.
6. Output: Model menghasilkan daftar objek yang terdeteksi, lengkap dengan lokasi, kelas, dan tingkat kepercayaan.

3. Evolusi YOLO: Memahami Perbedaan Versi (YOLOv5, YOLOv7, YOLOv8, dst.)

YOLO telah mengalami perkembangan pesat sejak pertama kali diperkenalkan. Setiap versi baru membawa peningkatan dalam hal akurasi, kecepatan, dan efisiensi.

3.1. YOLOv5

YOLOv5 (arsitektur YOLOv5) adalah salah satu versi YOLO yang paling populer karena kemudahan penggunaannya dan performanya yang baik. Beberapa ciri khas YOLOv5 adalah:

• Ditulis dalam bahasa pemrograman Python dengan framework PyTorch, membuatnya lebih mudah diakses dan dimodifikasi.
• Menawarkan berbagai model dengan ukuran yang berbeda (Nano, Small, Medium, Large, XLarge), memungkinkan pengguna untuk memilih model yang sesuai dengan kebutuhan komputasi mereka.
• Menggunakan arsitektur CSPDarknet53 sebagai backbone.
• Menggunakan PANet sebagai neck.
• Fokus pada kemudahan pelatihan (training) dan deployment.

3.2. YOLOv7

YOLOv7 diklaim sebagai salah satu detektor objek tercepat dan paling akurat pada saat dirilis. Beberapa peningkatan utama YOLOv7 dibandingkan YOLOv5 meliputi:

• Model E-ELAN (Extended Efficient Layer Aggregation Network): Arsitektur baru yang dirancang untuk meningkatkan efisiensi dan akurasi.
• Model scaling: Teknik untuk menyesuaikan ukuran model agar sesuai dengan kebutuhan komputasi yang berbeda.
• Trainable bag-of-freebies: Metode optimasi yang meningkatkan akurasi tanpa menambah biaya inferensi.

3.3. YOLOv8

YOLOv8 (YOLOv8 architecture) adalah versi terbaru dari YOLO yang dikembangkan oleh Ultralytics, perusahaan yang sama di balik YOLOv5. Beberapa fitur utama YOLOv8 adalah:

• Anchor-free: Tidak lagi menggunakan anchor boxes seperti versi sebelumnya, yang menyederhanakan proses training dan inference.
• Loss function baru: Menggunakan Distribution Focal Loss (DFL) untuk meningkatkan akurasi bounding box.
• Arsitektur yang lebih fleksibel: Mendukung berbagai tugas selain deteksi objek, seperti klasifikasi, segmentasi, dan pose estimation.

Secara umum, YOLOv8 menawarkan peningkatan akurasi dan fleksibilitas dibandingkan versi sebelumnya, tetapi mungkin membutuhkan sumber daya komputasi yang lebih besar.

Perbandingan Singkat Antar Versi YOLO

4. Implementasi YOLO: Panduan Langkah demi Langkah

Implementasi YOLO (implementasi YOLO) dapat dilakukan dengan relatif mudah menggunakan berbagai library dan framework yang tersedia.

4.1. Memilih Library dan Framework

Beberapa library dan framework yang populer untuk implementasi YOLO antara lain:

• OpenCV: Library open-source yang sangat populer untuk berbagai tugas computer vision, termasuk deteksi objek. OpenCV menyediakan fungsi-fungsi untuk memproses gambar, video, dan menjalankan model deep learning.
• PyTorch: Framework deep learning yang fleksibel dan banyak digunakan untuk penelitian dan pengembangan. PyTorch menyediakan interface yang mudah digunakan untuk membangun dan melatih model YOLO.
• TensorFlow: Framework deep learning lain yang populer, dikembangkan oleh Google. TensorFlow menawarkan berbagai tools dan resource untuk deep learning, termasuk dukungan untuk YOLO.

Pilihan library dan framework tergantung pada preferensi pribadi, kebutuhan proyek, dan sumber daya yang tersedia.

4.2. Instalasi dan Konfigurasi

Setelah memilih library, langkah selanjutnya adalah melakukan instalasi. Berikut adalah contoh instalasi untuk OpenCV dan PyTorch:

OpenCV:

pip install opencv-python

PyTorch:

# Sesuaikan dengan konfigurasi CUDA Anda
pip install torch torchvision torchaudio

4.3. Memuat Model Pre-trained

Model pre-trained YOLO adalah model yang telah dilatih sebelumnya pada dataset besar seperti COCO (Common Objects in Context). Model ini dapat langsung digunakan untuk mendeteksi objek tanpa perlu melakukan training dari awal. Cara memuat model pre-trained berbeda-beda tergantung library yang digunakan.

Contoh (PyTorch):

import torch

# Memuat model YOLOv5 (misalnya, yolov5s)
model = torch.hub.load('ultralytics/yolov5', 'yolov5s')

# atau memuat model YOLOv8
# model = torch.hub.load('ultralytics/yolov8', 'yolov8n')

4.4. Preprocessing Data

Sebelum gambar atau video dimasukkan ke dalam model, data perlu diproses terlebih dahulu. Langkah-langkah preprocessing yang umum meliputi:

• Resizing: Mengubah ukuran gambar agar sesuai dengan ukuran input model.
• Normalization: Menyesuaikan nilai piksel gambar agar berada dalam rentang tertentu (misalnya, 0-1).

Penggunaan dataset deteksi objek (dataset deteksi objek) yang baik akan membantu proses preprocessing. Dataset ini biasanya sudah memiliki format yang terstruktur dan siap digunakan.

Contoh (PyTorch):

import cv2

# Membaca gambar
img = cv2.imread('gambar.jpg')

# Resizing gambar
img = cv2.resize(img, (640, 640))

# Konversi ke format yang sesuai dengan PyTorch (BGR ke RGB)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

# Normalisasi
img = img / 255.0

# Konversi ke tensor PyTorch
img = torch.from_numpy(img).permute(2, 0, 1).float().unsqueeze(0)

4.5. Deteksi Objek: Menerapkan Model pada Gambar/Video

Setelah preprocessing, data siap untuk dimasukkan ke dalam model.

Contoh Deteksi Objek pada Gambar (PyTorch):

# Melakukan inferensi
results = model(img)

# Hasil deteksi
print(results.pandas().xyxy[0])

Contoh Deteksi Objek pada Video (OpenCV dan PyTorch):

import cv2
import torch

# Memuat model YOLOv5
model = torch.hub.load('ultralytics/yolov5', 'yolov5s')

# Membuka video
cap = cv2.VideoCapture('video.mp4')  # Ganti 'video.mp4' dengan nama file video Anda

while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break

    # Preprocessing (seperti contoh sebelumnya)
    frame = cv2.resize(frame, (640, 640))
    frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    frame_tensor = torch.from_numpy(frame_rgb).permute(2, 0, 1).float().unsqueeze(0) / 255.0

    # Deteksi objek
    results = model(frame_tensor)

    # Mendapatkan hasil deteksi
    detections = results.pandas().xyxy[0]

    # Menggambar bounding box dan label pada frame (lihat bagian Visualisasi Hasil Deteksi)

    # Menampilkan frame dengan hasil deteksi
    cv2.imshow('YOLO Object Detection', frame)

    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

# Implementasi serupa dapat digunakan untuk library OpenCV (YOLO with OpenCV), dan (YOLO PyTorch tutorial).
# Dengan sedikit penyesuaian, kode diatas dapat diubah menjadi implementasi YOLO Python.

4.6. Visualisasi Hasil Deteksi: Menampilkan Bounding Box dan Label

Untuk memvisualisasikan hasil deteksi, kita dapat menggambar bounding box dan label kelas pada gambar atau frame video.

Contoh (OpenCV):

    for *_, row in detections.iterrows():
        x1, y1, x2, y2, confidence, class_id = row
        x1, y1, x2, y2 = int(x1), int(y1), int(x2), int(y2)
        label = f"{model.names[int(class_id)]} {confidence:.2f}"

        # Menggambar bounding box
        cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)

        # Menambahkan label
        cv2.putText(frame, label, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

Kode di atas akan menghasilkan frame video dengan bounding box dan label kelas untuk setiap objek yang terdeteksi.

Baca juga: Panduan Lengkap Image Segmentation Pengertian, Jenis, dan Aplikasinya

Jika ingin melakukan custom object detection, (custom object detection YOLO) kita perlu melakukan training model YOLO pada dataset yang berisi gambar dan label objek yang ingin kita deteksi.

5. Kesimpulan: Aplikasi Masa Depan dan Potensi YOLO

YOLO adalah algoritma deteksi objek yang powerful dan efisien, menawarkan kecepatan dan akurasi yang tinggi. Dengan arsitektur yang terus berkembang dan berbagai library yang mendukung, YOLO semakin mudah diimplementasikan untuk berbagai aplikasi.

Di masa depan, YOLO dan algoritma deteksi objek lainnya akan terus memainkan peran penting dalam berbagai bidang, seperti:

• Kendaraan otonom yang lebih canggih: Deteksi objek yang lebih akurat dan real-time akan menjadi kunci untuk mewujudkan mobil self-driving yang aman dan andal.
• Robotika yang lebih cerdas: Robot akan semakin mampu memahami dan berinteraksi dengan lingkungannya berkat kemampuan deteksi objek yang semakin baik.

Baca juga: AI dalam Pencarian dan Penyelamatan Korban Bencana: Mempercepat Evakuasi

• Kota pintar: Sistem deteksi objek dapat digunakan untuk memantau lalu lintas, keamanan publik, dan berbagai aspek lain dari kehidupan perkotaan.
• Kesehatan: Deteksi objek dapat digunakan untuk membantu diagnosis medis, analisis citra medis, dan pemantauan pasien.

YOLO telah membuktikan dirinya sebagai game-changer dalam dunia computer vision, dan potensinya masih sangat besar untuk dieksplorasi lebih lanjut.

Jika Anda tertarik untuk mengimplementasikan solusi berbasis AI, seperti deteksi objek dengan YOLO, atau mengembangkan platform digital yang lebih canggih, Kirim.ai hadir untuk membantu. Kirim.ai menyediakan platform SaaS dengan berbagai tools AI, termasuk pemrosesan teks, audio, gambar, dan video. Kami juga menawarkan layanan pengembangan aplikasi seluler (iOS & Android), pengembangan website, serta strategi pemasaran digital terintegrasi. Pelajari lebih lanjut tentang bagaimana Kirim.ai dapat membantu mewujudkan visi digital Anda.