YOLO OBJECT DETECTION WITH OPENCV

.Pendeteksi objek Yolo untuk medeteksi benda tidak bergerak maupun benda yang bergerak / bias
mendeteksi dimana pun benda berada menggunakan deep learning, openCV dan phyton.

.openCV (open source computer vision library), computer vision adalah kemampuan mesin dalam
melihat atau meng-ekstrak informasi dalam suatu gambar. Jadi openCV adalah sebuah library yang
digunakan untuk mengetahui atau megekstrak informasi yang ada disuatu gambar atau video.

What is the yolo object detector ??

ketika mendeteksi sebuah objek maka tiga detector object utama:

1. R-CNN dan variannya, termasuk R-CNN asli, Fast R-CNN, dan R-CNN Lebih Cepat
2. Single Shot Detector (SSDs)
3. YOLO

R-CNN adalah salah satu detektor objek berbasis pembelajaran pertama yang dalam dan merupakan
contoh detektor dua tahap.

1. Dalam publikasi R-CNN pertama, hierarki fitur Kaya untuk deteksi objek akurat dan segmentasi semantik,
(2013) Girshick et al. mengusulkan detektor objek yang memerlukan algoritme seperti Pencarian Selektif
(atau yang setara) untuk mengajukan kotak kandidat yang dapat memuat objek.
2. Daerah-daerah ini kemudian dilewatkan ke CNN untuk klasifikasi, akhirnya mengarah ke salah satu
detektor objek berbasis pembelajaran pertama yang mendalam.
. Masalah dengan metode R-CNN standar adalah bahwa itu sangat lambat dan bukan pendeteksi objek ujung-ke-
ujung yang lengkap

Girshick et al. menerbitkan makalah kedua pada tahun 2015, berjudul Fast R-CNN. Algoritma Fast R-CNN
membuat perbaikan yang cukup besar pada R-CNN asli, yaitu meningkatkan akurasi dan mengurangi waktu yang
diperlukan untuk melakukan forward pass; Namun, model ini masih mengandalkan algoritma proposal wilayah
eksternal.

Tidak sampai makalah tindak lanjut 2015 Girshick et al., Lebih cepat R-CNN: Menuju Deteksi Objek Real-Time
dengan Jaringan Proposal Wilayah, R-CNN menjadi detektor objek pembelajaran dalam yang ujung ke ujung yang
benar oleh menghapus persyaratan Pencarian Selektif dan sebagai gantinya mengandalkan Jaringan Proposal
Wilayah (RPN) yaitu (1) sepenuhnya konvolusional dan (2) dapat memprediksi kotak pembatas objek dan skor
"keberatan" (yaitu, skor yang mengukur seberapa besar kemungkinan suatu wilayah dari suatu gambar dapat
mengandung suatu gambar). Output dari RPN kemudian dilewatkan ke komponen R-CNN untuk klasifikasi akhir
dan pelabelan.

Sementara R-CNN cenderung sangat akurat, masalah terbesar dengan keluarga jaringan R-CNN
adalah kecepatannya - mereka sangat lambat, hanya memperoleh 5 FPS pada GPU.

Untuk membantu meningkatkan kecepatan detektor objek berbasis pembelajaran dalam, baik Detektor Tembakan
Tunggal (SSD) dan YOLO menggunakan strategi detektor satu tahap.

Algoritma ini memperlakukan deteksi objek sebagai masalah regresi, mengambil gambar input yang diberikan dan
secara bersamaan mempelajari koordinat kotak pembatas dan probabilitas label kelas terkait

Secara umum, single-stage pemindai cenderung akan sedikit lebih akurat daripada two-
stage pemindai tetapi tidak secara signifikan lebih cepat.
Yolo adalah sebuah contoh yang baik dari satu tahap detektor .
Diperkenalkan pertama kali di 2015 oleh redmon et al . , mereka kertas , anda hanya sekali
lihat: bersatu , deteksi real-time objek , rincian objek detektor mampu real-time objek deteksi
super , mendapatkan 45 fps di sebuah gpu . ~

Catatan: Varian yang lebih kecil dari model mereka yang disebut "Fast YOLO" mengklaim dapat mencapai 155 FPS
pada GPU.

YOLO telah melalui sejumlah iterasi yang berbeda, termasuk YOLO9000: Better, Faster, Stronger (mis., YOLOv2),
mampu mendeteksi lebih dari 9.000 objek detektor.

Redmon dan Farhadi mampu mencapai sejumlah besar deteksi objek dengan melakukan pelatihan bersama untuk
deteksi dan klasifikasi objek. Menggunakan pelatihan bersama, penulis melatih YOLO9000 secara bersamaan pada
dataset klasifikasi ImageNet dan dataset deteksi COCO. Hasilnya adalah model YOLO, yang disebut YOLO9000,
yang dapat memprediksi deteksi untuk kelas objek yang tidak memiliki label data deteksi.

Meskipun menarik dan novel, kinerja YOLOv2 sedikit underwhelming mengingat judul dan abstrak makalahnya.

Pada COCO versi 156 kelas, YOLO9000 mencapai 16% rata-rata Presisi Rata-Rata (MAP), dan ya, sementara
YOLO dapat mendeteksi 9.000 kelas terpisah, keakuratannya tidak seperti yang kita inginkan.

Redmon dan Farhadi baru-baru ini menerbitkan makalah YOLO baru, YOLOv3: An Incremental Improvement
(2018). YOLOv3 secara signifikan lebih besar dari model sebelumnya tetapi, menurut pendapat saya, yang terbaik
dari keluarga YOLO dari detektor objek.

Kami akan menggunakan YOLOv3 dalam posting blog ini, khususnya, YOLO dilatih tentang dataset COCO.

Dataset COCO terdiri dari 80 label, termasuk, tetapi tidak terbatas pada:

1. Orang-orang
2. Sepeda
3. Mobil dan truk
4. Pesawat terbang
5. Hentikan rambu dan hidran bakar
6. Hewan, termasuk kucing, anjing, burung, kuda, sapi, dan domba, untuk beberapa nama
Benda dapur dan makan, seperti gelas anggur, gelas, garpu, pisau, sendok, dll.
…dan banyak lagi!
Anda dapat menemukan daftar lengkap dari apa yang YOLO latih pada dataset COCO dapat dideteksi menggunakan
tautan ini.

Saya akan mengakhiri bagian ini dengan mengatakan bahwa setiap akademisi perlu membaca surat kabar YOLO
dan laporan teknologi Redmon - tidak hanya novel dan wawasan mereka juga sangat menghibur.

Namun serius, jika Anda tidak melakukan hal lain hari ini, baca laporan teknologi YOLOv3.

Hanya 6 halaman dan salah satu halaman itu hanya referensi / kutipan.

Lebih jauh lagi, laporan teknologi itu jujur sehingga makalah akademik jarang, jika pernah ada.

Struktur proyek
Mari kita lihat tata letak proyek hari ini. Anda dapat menggunakan GUI OS Anda (Finder untuk OSX, Nautilus
untuk Ubuntu), tetapi Anda mungkin merasa lebih mudah dan lebih cepat untuk menggunakan perintah tree di
terminal Anda:
yolo-coco /: File objek YOLOv3 yang diprogram sebelumnya (pada set data COCO). Ini dilatih oleh tim Darknet.
images /: Folder ini berisi empat gambar statis yang akan kami deteksi objeknya untuk tujuan pengujian dan
evaluasi.
videos /: Setelah melakukan deteksi objek dengan YOLO pada gambar, kami akan memproses video secara real
time. Direktori ini berisi empat video sampel untuk Anda coba.
output /: Output video yang telah diproses oleh YOLO dan dijelaskan dengan kotak pembatas dan nama kelas dapat
masuk ke folder ini.
Kami sedang meninjau dua skrip Python - yolo.py dan yolo_video.py. Skrip pertama adalah untuk gambar dan
kemudian kami akan mengambil apa yang kami pelajari dan menerapkannya ke video di skrip kedua.

Deteksi objek YOLO dalam gambar

Mari mulai menerapkan detektor objek YOLO pada gambar!

Buka file yolo.py di proyek Anda dan masukkan kode berikut:

Semua yang Anda perlukan terinstal untuk skrip ini OpenCV 3.4.2+ dengan binding Python. Anda dapat
menemukan tutorial instalasi OpenCV saya di sini, perlu diingat bahwa OpenCV 4 sedang dalam versi
beta saat ini - Anda mungkin mengalami masalah dalam menginstal atau menjalankan skrip tertentu
karena ini bukan rilis resmi. Untuk saat ini saya sarankan pergi untuk OpenCV 3.4.2+. Anda benar-benar
dapat berdiri dan berjalan dalam waktu kurang dari 5 menit dengan pip juga. Pertama, kami mengimpor
paket-paket yang diperlukan - selama OpenCV dan NumPy diinstal, penerjemah Anda akan dengan
mudah melewati baris-baris ini. Sekarang mari kita uraikan empat argumen baris perintah. Argumen baris
perintah diproses pada saat runtime dan memungkinkan kami untuk mengubah input ke skrip kami dari
terminal. Jika Anda tidak terbiasa dengan mereka, saya mendorong Anda untuk membaca lebih banyak di
tutorial saya sebelumnya. Argumen baris perintah kami meliputi:

--gambar: Jalur ke gambar input. Kami akan mendeteksi objek dalam gambar ini menggunakan YOLO.
--yolo: Jalur dasar ke direktori YOLO. Script kami kemudian akan memuat file YOLO yang diperlukan untuk
melakukan deteksi objek pada gambar.
--confidence: Probabilitas minimum untuk memfilter deteksi lemah. Saya telah memberikan ini nilai default 50%
(0,5), tetapi Anda harus merasa bebas untuk bereksperimen dengan nilai ini.
--threshold: Ini adalah ambang penindasan non-maksimal kami dengan nilai default 0,3. Anda dapat membaca lebih
lanjut tentang penindasan non-maksimal di sini.
Setelah parsing, variabel args sekarang menjadi kamus yang berisi pasangan nilai kunci untuk argumen baris
perintah. Anda akan melihat argumen beberapa kali di bagian lain skrip ini.

Mari memuat label kelas kami dan mengatur warna acak untuk masing-masing:
Di sini kita memuat semua LABEL kelas kita (perhatikan argumen baris perintah pertama, args ["yolo"] digunakan)
pada Baris 21 dan 22. WARNA acak kemudian ditugaskan untuk setiap label pada Baris 25-27.

Mari kita turunkan jalur ke bobot dan konfigurasi file YOLO diikuti dengan memuat YOLO dari disk:

Untuk memuat YOLO dari disk pada Baris 35, kami akan memanfaatkan fungsi DNN OpenCV yang disebut
cv2.dnn.readNetFromDarknet. Fungsi ini membutuhkan configPath dan weightsPath yang dibuat melalui argumen
baris perintah pada Baris 30 dan 31.

Saya tidak bisa cukup menekankan hal ini: Anda memerlukan setidaknya OpenCV 3.4.2 untuk menjalankan kode ini
karena diperlukan modul dnn yang diperbarui untuk memuat YOLO.

Mari memuat gambar dan mengirimkannya melalui jaringan:

Di blok ini kita:

Muat gambar input dan ekstrak dimensinya (Baris 38 dan 39).

Tentukan nama-nama lapisan keluaran dari model YOLO (Baris 42 dan 43).
Bangun gumpalan dari gambar (Baris 48 dan 49). Apakah Anda bingung tentang apa itu gumpalan atau apa yang
dilakukan cv2.dnn.blobFromImage? Berikan posting blog ini bacaan.
Sekarang setelah gumpalan kami siap, kami akan

Lakukan umpan maju melalui jaringan YOLO kami (Baris 50 dan 52)
Tampilkan waktu inferensi untuk YOLO (Jalur 56)
Apa gunanya deteksi objek kecuali kami memvisualisasikan hasil kami? Ayo lakukan langkah sekarang untuk
memfilter dan memvisualisasikan hasil kami.

Tapi pertama-tama, mari kita inisialisasi beberapa daftar yang kita perlukan dalam proses melakukannya:

Daftar ini meliputi:

kotak: kotak pembatas kami di sekitar objek.

confidences: Nilai kepercayaan yang diberikan YOLO ke objek. Nilai kepercayaan yang lebih rendah menunjukkan
bahwa objek itu mungkin bukan apa yang dipikirkan jaringan itu. Ingat dari argumen baris perintah kami di atas
bahwa kami akan memfilter objek yang tidak memenuhi batas 0,5.
classIDs: label kelas objek yang terdeteksi.
Mari mulai mengisi daftar ini dengan data dari YOLO layerOutput kami:

Ada banyak hal di sini dalam blok kode ini - mari kita jabarkan.

Di blok ini, kami:

Lingkarkan di atas masing-masing layerOutput (dimulai pada Baris 65).

Loop atas setiap deteksi dalam output (loop bersarang dimulai pada Baris 67).
Ekstrak classID dan kepercayaan diri (Baris 70-72).
Gunakan kepercayaan diri untuk memfilter deteksi lemah (Jalur 76).
Sekarang kami telah memfilter deteksi yang tidak diinginkan, kami akan:

Koordinat kotak pembatas skala sehingga kami dapat menampilkannya dengan benar pada gambar asli kami (Baris
81).
Ekstrak koordinat dan dimensi kotak pembatas (Baris 82). YOLO mengembalikan koordinat kotak pembatas dalam
bentuk: (centerX, centerY, lebar, dan tinggi).
Gunakan informasi ini untuk memperoleh koordinat kiri-atas (x, y) dari kotak pembatas (Baris 86 dan 87).
Perbarui kotak, rahasia, dan daftar classID (Baris 91-93).
Dengan data ini, kami sekarang akan menerapkan apa yang disebut "non-maxima suppression":

YOLO tidak menerapkan penindasan non-maksimal untuk kita, jadi kita perlu menerapkannya secara eksplisit.

Menerapkan penindasan non-maksimal menekan kotak batas yang tumpang tindih secara signifikan, hanya
menyimpan yang paling percaya diri.

NMS juga memastikan bahwa kami tidak memiliki kotak pembatas yang berlebihan atau tidak tersedia.

Mengambil keuntungan dari implementasi modul NN bawaan OpenCV dari NMS, kami melakukan penindasan non-
maksimal pada Baris 97 dan 98. Yang diperlukan adalah kami mengirimkan kotak pembatas, kerahasiaan, serta
ambang kepercayaan dan ambang NMS kami.

Jika Anda membaca blog ini, Anda mungkin bertanya-tanya mengapa kami tidak menggunakan implementasi
IMMS saya di NMS. Alasan utamanya adalah bahwa fungsi NMSBoxes sekarang berfungsi di OpenCV.
Sebelumnya gagal untuk beberapa input dan menghasilkan pesan kesalahan. Sekarang fungsi NMSBox berfungsi,
kita dapat menggunakannya dalam skrip kita sendiri.

Mari menggambar kotak dan teks kelas pada gambar!

Dengan asumsi setidaknya ada satu deteksi (Jalur 101), kami melanjutkan untuk mengulang idx yang ditentukan
oleh penindasan non-maksimal.
Kemudian, kita cukup menggambar kotak pembatas dan teks pada gambar menggunakan warna kelas acak kita
(Garis 105-113).

Terakhir, kami menampilkan gambar kami hingga pengguna menekan tombol apa saja pada keyboard mereka
(memastikan jendela yang dibuka oleh OpenCV dipilih dan difokuskan).

Untuk mengikuti panduan ini, pastikan Anda menggunakan bagian "Unduhan" dari tutorial ini untuk mengunduh
kode sumber, model YOLO, dan contoh gambar.

Dari sana, buka terminal dan jalankan perintah berikut:

Di sini Anda dapat melihat bahwa YOLO tidak hanya mendeteksi setiap orang di gambar input, tetapi juga koper-
kopernya!

Selain itu, jika Anda melihat di sudut kanan gambar, Anda akan melihat bahwa YOLO juga mendeteksi tas tangan
di bahu wanita itu.

Mari kita coba contoh lain:

Gambar di atas berisi seseorang (saya sendiri) dan seekor anjing (Jemma, beagle keluarga).

YOLO juga mendeteksi monitor TV dan kursi juga. Saya khususnya terkesan bahwa YOLO dapat mendeteksi kursi
tersebut karena “kursi bayi” buatan tangan dan kuno.

Menariknya, YOLO berpikir ada "remote" di tangan saya. Ini sebenarnya bukan remote - itu adalah pantulan kaca
pada pita VHS; Namun, jika Anda menatap wilayah itu sebenarnya terlihat seperti itu bisa menjadi remote.

Contoh gambar berikut menunjukkan keterbatasan dan kelemahan detektor objek YOLO:

Sementara botol anggur, meja makan, dan vas terdeteksi dengan benar oleh YOLO, hanya satu dari dua gelas anggur
yang terdeteksi dengan benar.

Kita membahas mengapa YOLO bergelut dengan benda-benda yang saling berdekatan di bagian "Keterbatasan dan
kekurangan detektor objek YOLO" di bawah ini.

Mari kita coba satu gambar terakhir:

YOLO mampu mendeteksi setiap pemain di lapangan dengan benar, termasuk bola itu sendiri. Perhatikan orang di
latar belakang yang terdeteksi meskipun area sangat kabur dan sebagian dikaburkan.

YOLO object detection in video streams

Sekarang kami telah belajar cara menerapkan detektor objek YOLO ke gambar tunggal, mari kita juga
memanfaatkan YOLO untuk melakukan deteksi objek dalam file video input juga.

Buka file yolo_video.py dan masukkan kode berikut:

Kami mulai dengan argumen impor dan baris perintah kami.

Perhatikan bahwa skrip ini tidak memiliki argumen --image seperti sebelumnya. Untuk
menggantikannya, kami sekarang memiliki dua argumen terkait video:

--input: Jalur ke file input video.

--output: Jalur kami ke file video output.

Dengan argumen ini, Anda sekarang dapat menggunakan video yang Anda rekam adegan dengan ponsel
cerdas Anda atau video yang Anda temukan online. Anda kemudian dapat memproses file video
menghasilkan video output beranotasi. Tentu saja jika Anda ingin menggunakan webcam Anda untuk
memproses streaming video langsung, itu mungkin juga. Cukup temukan contoh di PyImageSearch di
mana kelas VideoStream dari imutils.video digunakan dan buat beberapa perubahan kecil.

Selanjutnya, blok berikutnya identik dengan blok dari skrip pemrosesan gambar YOLO:

Di sini kita memuat label dan menghasilkan warna diikuti dengan memuat model YOLO kami dan
menentukan nama-nama lapisan keluaran.

Selanjutnya, kami akan menangani beberapa tugas khusus video:

Di blok ini, kami:

Buka penunjuk file ke file video untuk membaca bingkai di loop yang akan datang (Baris 45).

Inisialisasi penulis video dan dimensi bingkai kami (Baris 46 dan 47).

Cobalah untuk menentukan jumlah total frame dalam file video sehingga kami dapat memperkirakan
berapa lama pemrosesan seluruh video akan memakan waktu (Garis 50-61).

Sekarang kami siap untuk mulai memproses bingkai satu per satu:
Kami mendefinisikan loop sementara (Baris 64) dan kemudian kami mengambil bingkai pertama kami
(Baris 66).

Kami melakukan pemeriksaan untuk melihat apakah itu adalah frame terakhir dari video. Jika demikian,
kita perlu istirahat dari loop sementara (Baris 70 dan 71).

Selanjutnya, kami mengambil dimensi bingkai jika belum diambil (Garis 74 dan 75).

Selanjutnya, mari kita lakukan umpan maju YOLO, menggunakan bingkai kita saat ini sebagai input:

Di sini kita membangun gumpalan dan mengirimkannya melalui jaringan, memperoleh prediksi. Saya
telah mengelilingi operasi umpan maju dengan cap waktu sehingga kami dapat menghitung waktu yang
telah berlalu untuk membuat prediksi pada satu bingkai - ini akan membantu kami memperkirakan
waktu yang dibutuhkan untuk memproses seluruh video.

Kami kemudian akan melanjutkan dan menginisialisasi tiga daftar yang sama yang kami gunakan dalam
skrip sebelumnya: kotak, kerahasiaan, dan classID.

Blok berikutnya ini, sekali lagi, identik dengan skrip kami sebelumnya:
Dalam blok kode ini, kami:

Loop atas lapisan dan deteksi keluaran (Baris 94-96).

Ekstrak classID dan saring prediksi yang lemah (Lines 99-105).

Hitung koordinat kotak pembatas (Garis 111-117).

Perbarui daftar kami masing-masing (Baris 121-123).

Selanjutnya, kami akan menerapkan penindasan non-maksimal dan mulai melanjutkan untuk
membubuhi keterangan pada frame:
Anda harus mengenali garis-garis ini juga. Disini kita:

Terapkan NMS menggunakan fungsi cv2.dnn.NMSBoxes (Baris 127 dan 128) untuk menekan kotak
pembatas yang tumpang tindih dan lemah. Anda dapat membaca lebih lanjut tentang penindasan non-
maksimal di sini.

Lingkari idx yang dihitung oleh NMS dan gambar kotak + label pembatas yang sesuai (Baris 131-144).

Mari kita selesaikan skrip:

Untuk menyelesaikannya, kami cukup:

Inisialisasi penulis video kami jika perlu (Baris 147-151). Penulis akan diinisialisasi pada iterasi pertama
loop.

Cetak perkiraan kami tentang berapa lama waktu yang dibutuhkan untuk memproses video (Baris 154-
158).

Tulis bingkai ke file video output (Baris 161).

Pembersihan dan lepaskan pointer (Baris 165 dan 166).

Untuk menerapkan deteksi objek YOLO ke aliran video, pastikan Anda menggunakan bagian "Unduhan"
dari posting blog ini untuk mengunduh sumber, detektor objek YOLO, dan contoh video.

Dari sana, buka terminal dan jalankan perintah berikut:

Di atas Anda dapat melihat kutipan GIF dari video pengejaran mobil yang saya temukan di YouTube.

Dalam video / GIF, Anda dapat melihat tidak hanya kendaraan yang terdeteksi, tetapi orang-orang, serta
lampu lalu lintas, juga terdeteksi!

Detektor objek YOLO berkinerja cukup baik di sini. Mari kita coba klip video berbeda dari video
pengejaran mobil yang sama:

Tersangka sekarang melarikan diri dari mobil dan berlari melintasi tempat parkir.

YOLO sekali lagi dapat mendeteksi orang.

Pada satu titik, tersangka sebenarnya dapat kembali ke mobil mereka dan melanjutkan pengejaran -
mari kita lihat juga bagaimana kinerja YOLO di sana:
Sebagai contoh terakhir, mari kita lihat bagaimana kita dapat menggunakan YOLO sebagai titik awal
untuk membangun penghitung lalu lintas:

Limitations and drawbacks of the YOLO object detector

Keterbatasan dan kelemahan terbesar dari objek detektor YOLO adalah:
Itu tidak selalu menangani benda kecil dengan baik
Terutama tidak menangani objek yang dikelompokkan berdekatan
Alasan pembatasan ini adalah karena algoritma YOLO itu sendiri:

Detektor objek YOLO membagi gambar input menjadi kisi SxS di mana setiap sel di kisi
memprediksi hanya satu objek.
Jika ada beberapa objek kecil dalam satu sel maka YOLO tidak akan dapat mendeteksinya, yang
pada akhirnya mengarah pada deteksi objek yang terlewat.
Oleh karena itu, jika Anda tahu dataset Anda terdiri dari banyak objek kecil yang dikelompokkan
berdekatan maka Anda sebaiknya tidak menggunakan detektor objek YOLO.

Dalam hal benda-benda kecil, F-R-CNN cenderung bekerja lebih baik; namun, ini juga yang
paling lambat.

SSD juga dapat digunakan di sini; Namun, SSD juga dapat berjuang dengan benda yang lebih
kecil (tapi tidak sebanyak YOLO).

SSD sering memberikan tradeoff yang bagus dalam hal kecepatan dan akurasi juga.

Perlu dicatat juga bahwa YOLO berjalan lebih lambat dari SSD dalam tutorial ini. Dalam tutorial
saya sebelumnya tentang deteksi objek OpenCV kami menggunakan SSD - satu umpan maju
dari SSD membutuhkan waktu ~ 0,03 detik.
Namun, dari tutorial ini, kita tahu bahwa umpan maju dari detektor objek YOLO membutuhkan
waktu ~ 0,3 detik, kira-kira urutan besarnya lebih lambat!

Jika Anda menggunakan objek dalam pembelajaran yang telah diprogram sebelumnya,
mendeteksi persediaan OpenCV, Anda mungkin ingin mempertimbangkan untuk menggunakan
SSD lebih dari YOLO. Dari pengalaman pribadi saya, saya jarang menemukan situasi di mana
saya perlu menggunakan YOLO melalui SSD:
Saya telah menemukan SSD jauh lebih mudah untuk dilatih dan kinerjanya dalam hal akurasi
hampir selalu mengungguli YOLO (setidaknya untuk set data yang pernah saya gunakan).
YOLO mungkin memiliki hasil yang sangat baik pada dataset COCO; Namun, saya belum
menemukan tingkat akurasi yang sama untuk tugas saya sendiri.
Karena itu, saya cenderung menggunakan panduan berikut ketika memilih detektor objek untuk
masalah yang diberikan:

Jika saya tahu saya perlu mendeteksi benda kecil dan kecepatan bukan masalah, saya cenderung
menggunakan F-R-CNN yang lebih cepat.
Jika kecepatan sangat penting, saya menggunakan YOLO.
Jika saya membutuhkan jalan tengah, saya cenderung menggunakan SSD.
Dalam sebagian besar situasi saya, saya akhirnya menggunakan SSD atau RetinaNet - keduanya
adalah keseimbangan yang sangat baik antara YOLO / Faster R-CNN.

Ingin melatih detektor objek pembelajaran Anda sendiri yang mendalam?

Model YOLO yang kami gunakan dalam tutorial ini telah dilatih sebelumnya pada dataset
COCO…

... tetapi bagaimana jika Anda ingin melatih detektor objek pembelajaran yang mendalam pada
dataset Anda sendiri?

Di dalam buku saya, Deep Learning for Computer Vision dengan Python, saya akan mengajari
Anda cara melatih R-CNN yang lebih cepat, Detektor Tembakan Tunggal (SSD), dan RetinaNet
ke:

Deteksi logo dalam gambar

Deteksi rambu lalu lintas (mis. Tanda berhenti, tanda hasil, dll.)
Mendeteksi tampilan depan dan belakang kendaraan (berguna untuk membangun aplikasi mobil
self-driving)
Mendeteksi senjata dalam aliran gambar dan video
Semua bab deteksi objek dalam buku ini menyertakan penjelasan terperinci dari kedua algoritma
dan kode, memastikan Anda akan dapat berhasil melatih detektor objek Anda sendiri.

Ringkasan

Dalam tutorial ini kami belajar cara melakukan deteksi objek YOLO menggunakan Deep
Learning, OpenCV, dan Python.
Kami kemudian membahas secara singkat arsitektur YOLO diikuti dengan menerapkan kode
Python ke:

Terapkan deteksi objek YOLO ke gambar tunggal

Terapkan pendeteksi objek YOLO ke streaming video
Pada komputer saya dengan prosesor Intel Xeon W 3GHz, satu umpan maju YOLO hanya
membutuhkan waktu ~ 0,3 detik; namun, dengan menggunakan Single Shot Detector (SSD) dari
tutorial sebelumnya, hanya menghasilkan deteksi 0,03 detik, urutan besarnya lebih cepat!

Untuk deteksi objek berbasis pembelajaran dalam waktu nyata pada CPU Anda dengan OpenCV
dan Python, Anda mungkin ingin mempertimbangkan untuk menggunakan SSD.

Jika Anda tertarik untuk melatih detektor objek pembelajaran dalam Anda sendiri pada
kumpulan data kustom Anda sendiri, pastikan untuk merujuk ke buku saya, Pembelajaran Jauh
untuk Penglihatan Komputer dengan Python, di mana saya memberikan panduan terperinci
tentang cara berhasil melatih detektor Anda sendiri.