Implementasi Praktis dari Algoritma Faster R-CNN untuk Deteksi Objek (Bagian 2 – dengan kode Python)

 

Pengantar

Tujuan di balik seri tulisan ini adalah untuk menunjukkan betapa bermanfaatnya berbagai jenis algoritma R-CNN. 

Dalam artikel ini, pertama-tama kita akan meringkas secara singkat apa yang kita pelajari di bagian 1, dan kemudian mendalami implementasi anggota tercepat dari keluarga R-CNN – Faster R-CNN. 

Daftar isi

1. Tinjauan singkat beberapa algoritma R-CNN untuk Deteksi Objek
2. Memahami rumusan masalah
3. Menyiapkan sistem
4. Eksplorasi data
5. Menerapkan Faster R-CNN 

Tinjauan Singkat Beberapa Algoritma R-CNN untuk Deteksi Objek

Mari kita merangkum beberapa algoritma dalam keluarga R-CNN (R-CNN, Fast R-CNN, dan Faster R-CNN) yang kita lihat di artikel pertama. Ini akan membantu meletakkan dasar untuk bagian implementasi ketika akan memprediksi kotak pembatas (bounding boxes) yang ada dalam gambar yang ada di data baru tapi tidak ada di data lama.

R-CNN mengekstrak sekelompok wilayah dari gambar yang diberikan menggunakan pencarian selektif, dan kemudian memeriksa apakah salah satu kotak ini berisi objek. Kita pertama-tama mengekstrak wilayah ini, dan untuk setiap wilayah, CNN digunakan untuk mengekstrak fitur tertentu. Akhirnya, fitur-fitur ini kemudian digunakan untuk mendeteksi objek. Sayangnya, R-CNN menjadi agak lambat karena beberapa langkah yang terlibat dalam proses ini.

R-CNN

Fast R-CNN, di sisi lain, meneruskan seluruh gambar ke ConvNet yang menghasilkan daerah yang diinginkan (bukan meneruskan daerah yang diekstraksi dari gambar). Selain itu, alih-alih menggunakan tiga model berbeda (seperti yang kita lihat di R-CNN), ia menggunakan model tunggal yang mengekstrak fitur dari wilayah, mengklasifikasikannya ke dalam kelas yang berbeda, dan mengembalikan kotak pembatas.

Semua langkah ini dilakukan secara bersamaan, sehingga membuatnya lebih cepat dieksekusi dibandingkan dengan R-CNN. R-CNN cepat, bagaimanapun, tidak cukup cepat ketika diterapkan pada dataset besar karena juga menggunakan pencarian selektif untuk mengekstraksi wilayah.

R-CNN cepat

R-CNN yang lebih cepat memperbaiki masalah pencarian selektif dengan menggantinya dengan Region Proposal Network (RPN). Kita pertama-tama mengekstrak peta fitur dari gambar input menggunakan ConvNet dan kemudian meneruskan peta tersebut melalui RPN yang mengembalikan proposal objek. Akhirnya, peta ini diklasifikasikan dan kotak pembatas diprediksi.

R-CNN lebih cepat

Saya telah merangkum di bawah ini langkah-langkah yang diikuti oleh algoritma R-CNN Lebih Cepat untuk mendeteksi objek dalam gambar:

1. Ambil gambar input dan berikan ke ConvNet yang mengembalikan peta fitur untuk gambar
2. Terapkan Jaringan Proposal Wilayah (RPN) pada peta fitur ini dan dapatkan proposal objek
3. Terapkan lapisan penyatuan ROI untuk menurunkan semua proposal ke ukuran yang sama
4. Terakhir, berikan proposal ini ke lapisan yang sepenuhnya terhubung untuk mengklasifikasikan kotak pembatas gambar apa pun yang diprediksi

Apa cara yang lebih baik untuk membandingkan algoritma yang berbeda ini selain dalam format tabel? Jadi di sini Anda pergi!

algoritma	Fitur	Prediksi waktu / gambar	Keterbatasan
CNN	Membagi citra menjadi beberapa wilayah dan kemudian mengklasifikasikan setiap wilayah ke dalam berbagai kelas.	-	Membutuhkan banyak wilayah untuk memprediksi secara akurat dan karenanya waktu komputasi yang tinggi.
R-CNN	Menggunakan pencarian selektif untuk menghasilkan wilayah. Ekstrak sekitar 2000 wilayah dari setiap gambar.	40-50 detik	Waktu komputasi yang tinggi karena setiap wilayah dilewatkan ke CNN secara terpisah. Juga, ia menggunakan tiga model berbeda untuk membuat prediksi.
Fast R-CNN	Setiap gambar dilewatkan hanya sekali ke CNN dan peta fitur diekstraksi. Pencarian selektif digunakan pada peta ini untuk menghasilkan prediksi. Menggabungkan ketiga model yang digunakan dalam R-CNN bersama-sama.	2 detik	Pencarian selektif lambat dan karenanya waktu komputasi masih tinggi.
Faster R-CNN	Mengganti metode pencarian selektif dengan jaringan proposal wilayah (RPN) yang membuat algoritme lebih cepat.	0,2 detik	Proposal objek membutuhkan waktu dan karena ada sistem yang berbeda yang bekerja satu demi satu, kinerja sistem tergantung pada kinerja sistem sebelumnya.

 

Sekarang setelah kita memahami topik ini, saatnya untuk beralih dari teori ke bagian praktis dari artikel kita. Mari kita implementasikan Faster R-CNN menggunakan dataset dengan potensi aplikasi kehidupan nyata!

Memahami Rumusan Masalah

Kita akan mengerjakan kumpulan data terkait perawatan kesehatan dan tujuannya di sini adalah untuk memecahkan masalah Deteksi Sel Darah. Tugas kita adalah mendeteksi semua Sel Darah Merah - Red Blood Cell (RBC), Sel Darah Putih - White Blood Cell  (WBC), dan Trombosit di setiap gambar yang diambil melalui pembacaan gambar mikroskopis. Di bawah ini adalah contoh seperti apa prediksi akhir kita:

Alasan memilih dataset ini adalah karena kepadatan sel darah merah, sel darah putih, dan Trombosit dalam aliran darah kita memberikan banyak informasi tentang sistem kekebalan dan hemoglobin. Ini dapat membantu mengidentifikasi apakah seseorang sehat atau tidak, dan jika ada perbedaan dalam darah mereka, tindakan dapat diambil dengan cepat untuk mendiagnosisnya.

Melihat sampel secara manual melalui mikroskop adalah proses yang membosankan. Dan di sinilah model Deep Learning memainkan peran penting. Mereka dapat mengklasifikasikan dan mendeteksi sel darah dari gambar mikroskopis dengan presisi yang mengesankan.

Dataset deteksi sel darah lengkap dapat diunduh dari sini. Perlu memodifikasi sedikit data untuk ruang lingkup artikel ini:

• Kotak pembatas telah dikonversi dari format .xml yang diberikan ke format .csv
• Membuat pemisahan set training testing pada seluruh dataset dengan memilih gambar secara acak untuk pemisahan

Perhatikan bahwa kita akan menggunakan framework Keras yang populer dengan backend TensorFlow di Python untuk melatih dan membangun model kita.

 

Menyiapkan Sistem

Sebelum kita benar-benar masuk ke fase pembuatan model, kita perlu memastikan bahwa pustaka dan kerangka kerja yang tepat telah diinstal. Pustaka di bawah ini diperlukan untuk menjalankan proyek ini:

• panda
• matplotlib
• aliran tensor
• keras – 2.0.3
• numpy
• opencv-python
• sklearn
• h5py

Sebagian besar pustaka yang disebutkan di atas sudah ada di mesin Anda jika Anda menginstal Anaconda dan Jupyter Notebooks. Selain itu, saya sarankan  mengunduh file requirement.txt dari tautan ini dan menggunakannya untuk menginstal pustaka sisanya. Ketik perintah berikut di terminal:

pip install -r requirement.txt

Eksplorasi Data

Itu selalu ide yang baik (dan terus terang, langkah wajib) untuk terlebih dahulu mengeksplorasi data yang kita miliki. Ini membantu tidak hanya menemukan pola tersembunyi, tetapi juga mendapatkan wawasan keseluruhan yang berharga tentang apa yang sedang kita kerjakan. Tiga file yang saya buat dari seluruh dataset adalah:

1. train_images: Gambar yang akan kita gunakan untuk melatih model. Kita memiliki kelas dan kotak pembatas sebenarnya untuk setiap kelas di folder ini.
2. test_images: Gambar dalam folder ini akan digunakan untuk membuat prediksi menggunakan model terlatih. Set ini tidak memiliki kelas dan kotak pembatas untuk kelas-kelas ini.
3. train.csv:  Berisi nama, kelas dan koordinat kotak pembatas untuk setiap gambar. Mungkin ada beberapa baris untuk satu gambar karena satu gambar dapat memiliki lebih dari satu objek.

Mari kita baca file .csv (Anda dapat membuat file .csv sendiri dari dataset asli jika Anda ingin bereksperimen) dan mencetak beberapa baris pertama. Pertama-tama kita harus mengimpor perpustakaan di bawah ini untuk ini:

# mengimpor perpustakaan yang diperlukan
impor panda sebagai pd
impor matplotlib.pyplot sebagai plt
%matplotlib sebaris
dari patch impor matplotlib

 

# baca file csv menggunakan fungsi read_csv dari pandas
kereta = pd.read_csv('kereta.csv')
kereta.kepala()

Ada 6 kolom dalam file kereta. Mari kita pahami apa yang diwakili oleh setiap kolom:

1. image_names: berisi nama gambar
2. cell_type: menunjukkan jenis sel
3. xmin: koordinat x dari bagian kiri bawah gambar
4. xmax: koordinat x bagian kanan atas gambar
5. ymin: koordinat y dari bagian kiri bawah gambar
6. ymax: y-koordinat bagian kanan atas gambar

Sekarang mari kita mencetak gambar untuk memvisualisasikan apa yang sedang kita kerjakan:

# membaca gambar tunggal menggunakan fungsi imread matplotlib
gambar = plt.imread('gambar/1.jpg')
plt.imshow(gambar)

Seperti inilah gambaran sel darah. Di sini, bagian biru mewakili sel darah putih, dan bagian yang sedikit merah mewakili sel darah merah. Mari kita lihat berapa banyak gambar, dan jenis kelas yang berbeda, yang ada di set pelatihan kita.

# Jumlah gambar pelatihan unik
melatih['image_names'].nunique()

Jadi, kita memiliki 254 gambar training.

# Jumlah kelas
melatih['cell_type'].value_counts()

Kita memiliki tiga kelas sel yang berbeda, yaitu RBC, WBC dan Trombosit. Terakhir, mari kita lihat bagaimana gambar dengan objek yang terdeteksi akan terlihat seperti:

gambar = plt.figure()

#tambahkan sumbu ke gambar
kapak = fig.add_axes([0,0,1,1])

# baca dan plot gambarnya
gambar = plt.imread('gambar/1.jpg')
plt.imshow(gambar)

# mengulangi gambar untuk objek yang berbeda
untuk _,baris di kereta[train.image_names == "1.jpg"].iterrows():
    xmin = baris.xmin
    xmax = baris.xmax
    ymin = baris.ymin
    ymax = baris.ymax
    
    lebar = xmax - xmin
    tinggi = ymax - ymin
    
    # tetapkan warna berbeda untuk kelas objek yang berbeda
    jika row.cell_type == 'RBC':
        warna tepi = 'r'
        ax.annotate('RBC', xy=(xmax-40,ymin+20))
    elif row.cell_type == 'WBC':
        warna tepi = 'b'
        ax.annotate('WBC', xy=(xmax-40,ymin+20))
    elif row.cell_type == 'Trombosit':
        warna tepi = 'g'
        ax.annotate('Trombosit', xy=(xmax-40,ymin+20))
        
    # tambahkan kotak pembatas ke gambar
    rect = patch.Rectangle((xmin,ymin), width, height, edgecolor = edgecolor, facecolor = 'none')
    
    ax.add_patch(persegi)

Seperti inilah contoh pelatihannya. Kita memiliki kelas yang berbeda dan kotak pembatas yang sesuai. Sekarang mari kita latih model kita pada gambar-gambar ini. Kita akan menggunakan perpustakaan keras_frcnn untuk melatih model kita serta untuk mendapatkan prediksi pada gambar uji.

 

Menerapkan R-CNN yang Lebih Cepat

Untuk mengimplementasikan algoritma Faster R-CNN, kita akan mengikuti langkah-langkah yang disebutkan dalam  repositori Github ini . Jadi sebagai langkah pertama, pastikan Anda mengkloning repositori ini. Buka jendela terminal baru dan ketik berikut ini untuk melakukan ini:

git clone https://github.com/kbardool/keras-frcnn.git

Pindahkan train_images dan test_images folder, serta train.csv file, untuk repositori kloning. Untuk melatih model pada dataset baru, format input harus:

jalur file,x1,y1,x2,y2,nama_kelas

di mana,

• filepath adalah jalur gambar pelatihan
• x1 adalah koordinat xmin untuk kotak pembatas
• y1 adalah koordinat ymin untuk kotak pembatas
• x2 adalah koordinat xmax untuk kotak pembatas
• y2 adalah koordinat ymax untuk kotak pembatas
• class_name adalah nama kelas di kotak pembatas itu

Kita perlu mengonversi format .csv menjadi file .txt yang akan memiliki format yang sama seperti yang dijelaskan di atas. Buat kerangka data baru, isi semua nilai sesuai format ke dalam kerangka data itu, lalu simpan sebagai file .txt.

data = pd.DataFrame()
data['format'] = kereta['nama_gambar']

# karena gambar ada di folder train_images, tambahkan train_images sebelum nama gambar
untuk saya dalam jangkauan(data.shape[0]):
    data['format'][i] = 'gambar_kereta/' + data['format'][i]

# tambahkan xmin, ymin, xmax, ymax dan kelas sesuai format yang diperlukan
untuk saya dalam jangkauan(data.shape[0]):
    data['format'][i] = data['format'][i] + ',' + str(train['xmin'][i]) + ',' + str(train['ymin'][ i]) + ',' + str(train['xmax'][i]) + ',' + str(train['ymax'][i]) + ',' + train['cell_type'][i ]

data.to_csv('annotate.txt', header=Tidak ada, indeks=Tidak ada, sep=' ')

Apa berikutnya?

Kita akan menggunakan file train_frcnn.py untuk melatih model.

cd keras-frcnn
python train_frcnn.py -o sederhana -p annotate.txt

Ini akan memakan waktu cukup lama untuk melatih model karena ukuran data. Jika memungkinkan, Anda dapat menggunakan GPU untuk mempercepat fase pelatihan. Anda juga dapat mencoba mengurangi jumlah epoch sebagai opsi alternatif. Untuk mengubah jumlah epoch, buka file train_frcnn.py di repositori kloning dan ubah  parameter num_epochs .

Setiap kali model melihat peningkatan, bobot dari epoch tersebut akan disimpan dalam direktori yang sama dengan “ model_frcnn.hdf5 ”. Bobot ini akan digunakan ketika kita membuat prediksi pada set tes.

Mungkin perlu banyak waktu untuk melatih model dan mendapatkan bobot, tergantung pada konfigurasi mesin Anda. Saya sarankan menggunakan bobot yang saya dapatkan setelah melatih model selama sekitar 500 epoch. Anda dapat mengunduh bobot ini  dari sini . Pastikan Anda menyimpan bobot ini di repositori kloning.

Jadi model kita telah dilatih dan bobotnya ditetapkan. Saatnya kita prediksi! Keras_frcnn membuat prediksi untuk gambar baru dan menyimpannya di folder baru. Kita hanya perlu membuat dua perubahan pada file test_frcnn.py untuk menyimpan gambar:

1. Hapus komentar dari baris terakhir file ini:
   cv2.imwrite('./results_imgs/{}.png'.format(idx),img)
2. Tambahkan komentar pada baris terakhir kedua dan ketiga terakhir dari file ini:
   # cv2.imshow('img', img) # cv2.waitKey(0)
   

Mari kita membuat prediksi untuk gambar baru:

python test_frcnn.py -p test_images

Terakhir, gambar dengan objek yang terdeteksi akan disimpan di folder “results_imgs”. Berikut adalah beberapa contoh prediksi yang saya dapatkan setelah menerapkan Faster R-CNN:

Hasil 1

Hasil 2

Hasil 3

Hasil 4

 

Catatan Akhir

Algoritma R-CNN benar-benar mutakhir untuk tugas deteksi objek. Ada lonjakan dalam beberapa tahun terakhir dalam jumlah aplikasi komputer visi yang dibuat, dan R-CNN adalah core sebagian besar dari mereka.

Keras_frcnn terbukti menjadi perpustakaan yang sangat baik untuk deteksi objek, dan selanjutnya kita akan fokus pada teknik yang lebih canggih seperti YOLO, SSD, dll.

Pengenalan Langkah-demi-Langkah tentang Algoritma Deteksi Objek Dasar (Bagian 1)

 

1. Cara Sederhana Menyelesaikan Tugas Deteksi Objek (menggunakan Deep Learning)

Gambar di bawah ini adalah contoh populer untuk mengilustrasikan cara kerja algoritma pendeteksian objek. Setiap objek dalam gambar, dari seseorang hingga layang-layang, telah ditemukan dan diidentifikasi dengan tingkat presisi tertentu.

Mari kita mulai dengan pendekatan deep learning yang paling sederhana, dan yang banyak digunakan, untuk mendeteksi objek dalam gambar – Convolutional Neural Networks atau CNN. 

Perhatikan gambar di bawah ini:

Kita meneruskan gambar ke network, dan kemudian dikirim melalui berbagai konvolusi dan pooling layers. Akhirnya, kita mendapatkan output dalam bentuk kelas objek. 

Untuk setiap gambar input, kita mendapatkan kelas yang sesuai sebagai output. Bisakah kita menggunakan teknik ini untuk mendeteksi berbagai objek dalam sebuah gambar? Ya kita bisa! Mari kita lihat bagaimana kita dapat memecahkan masalah deteksi objek umum menggunakan CNN.

1. Pertama, kita ambil gambar sebagai input:

2. Kemudian membagi gambar menjadi berbagai wilayah:

3. Kemudian mempertimbangkan setiap wilayah sebagai gambar terpisah.
4. Lewatkan semua wilayah (gambar) ini ke CNN dan klasifikasikan ke dalam berbagai kelas.
5. Setelah kita membagi setiap wilayah ke dalam kelas yang sesuai, kita dapat menggabungkan semua wilayah ini untuk mendapatkan gambar asli dengan objek yang terdeteksi:

Masalah dengan menggunakan pendekatan ini adalah objek dalam gambar dapat memiliki rasio aspek dan lokasi spasial yang berbeda. Misalnya, dalam beberapa kasus objek mungkin menutupi sebagian besar gambar, sementara di lain pihak, objek mungkin hanya menutupi sebagian kecil dari gambar. Bentuk objek mungkin juga berbeda (banyak terjadi dalam kasus penggunaan kehidupan nyata).

Sebagai hasil dari faktor-faktor ini, kita akan membutuhkan sejumlah besar wilayah yang menghasilkan banyak waktu komputasi. Maka untuk mengatasi masalah ini dan mengurangi jumlah region, kita dapat menggunakan CNN berbasis region, yang memilih region menggunakan metode proposal. Mari kita pahami apa yang bisa dilakukan CNN berbasis wilayah.

 

2. Memahami Jaringan Saraf Konvolusi Berbasis Wilayah (Region-Based Convolutional Neural Network)

2.1 Intuisi RCNN

Alih-alih mengerjakan sejumlah besar wilayah, algoritma RCNN mengusulkan sekelompok kotak pada gambar dan memeriksa apakah salah satu kotak ini berisi objek apa pun. RCNN menggunakan pencarian selektif untuk mengekstrak kotak-kotak ini dari sebuah gambar (kotak-kotak ini disebut wilayah).

Pertama-tama mari kita pahami apa itu pencarian selektif dan bagaimana pencarian itu mengidentifikasi berbagai wilayah. Pada dasarnya ada empat wilayah yang membentuk suatu objek: varying scales, colors, textures, and enclosure. Pencarian selektif mengidentifikasi pola-pola ini dalam gambar dan  mengusulkan berbagai wilayah berdasarkan itu. Berikut adalah ikhtisar singkat tentang cara kerja pencarian selektif (selective search):

• Pertama-tama mengambil gambar sebagai input:
  
• Kemudian, menghasilkan sub-segmentasi awal sehingga memiliki beberapa wilayah dari gambar ini:
  
• Teknik ini kemudian menggabungkan wilayah yang sama untuk membentuk wilayah yang lebih besar (berdasarkan kesamaan warna, kesamaan tekstur, kesamaan ukuran, dan kompatibilitas bentuk):
  
• Terakhir, daerah-daerah tersebut kemudian menghasilkan lokasi objek akhir (Region of Interest).

Di bawah ini adalah ringkasan singkat dari langkah-langkah yang diikuti di RCNN untuk mendeteksi objek:

1. Pertama-tama menggunakan jaringan saraf convolutional yang telah dilatih sebelumnya.
2. Kemudian, model ini dilatih ulang. Lapisan terakhir jaringan dilatih berdasarkan jumlah kelas yang perlu dideteksi.
3. Langkah ketiga adalah mendapatkan Region of Interest untuk setiap gambar. Kemudian membentuk kembali semua wilayah ini sehingga mereka bisa cocok dengan ukuran input CNN.
4. Setelah mendapatkan region, kita melatih SVM untuk mengklasifikasikan objek dan background. Untuk setiap kelas, kita melatih satu SVM biner.
5. Terakhir, melatih model regresi linier untuk menghasilkan kotak pembatas yang lebih ketat untuk setiap objek yang diidentifikasi dalam gambar.

Anda mungkin mendapatkan ide yang lebih baik dari langkah-langkah di atas dengan contoh visual (Gambar untuk contoh yang ditunjukkan di bawah ini diambil dari jurnal ini ). 

• Pertama, gambar diambil sebagai input:
  
• Kemudian, kita mendapatkan Regions of Interest (ROI) menggunakan beberapa metode proposal (misalnya, pencarian selektif seperti yang terlihat di atas):
  
• Semua wilayah ini kemudian dibentuk kembali sesuai input CNN, dan setiap wilayah diteruskan ke ConvNet:
  
• CNN kemudian mengekstrak fitur untuk setiap wilayah dan SVM digunakan untuk membagi wilayah ini ke dalam kelas yang berbeda:
  
• Akhirnya, regresi kotak pembatas ( Bbox reg ) digunakan untuk memprediksi kotak pembatas untuk setiap wilayah yang diidentifikasi:
  

Dan ini, singkatnya, adalah bagaimana RCNN membantu kita mendeteksi objek.

 

2.2 Masalah dengan RCNN

Sejauh ini, kita telah melihat bagaimana RCNN dapat membantu untuk deteksi objek. Tetapi teknik ini hadir dengan keterbatasannya sendiri. Pelatihan model RCNN mahal dan lambat berkat langkah-langkah di bawah ini:

• Mengekstrak 2.000 wilayah untuk setiap gambar berdasarkan pencarian selektif
• Ekstraksi fitur menggunakan CNN untuk setiap wilayah gambar. Misalkan kita memiliki N gambar, maka jumlah fitur CNN akan menjadi N*2.000
• Seluruh proses pendeteksian objek menggunakan RCNN memiliki tiga model:
  1. CNN untuk ekstraksi fitur
  2. Pengklasifikasi SVM linier untuk mengidentifikasi objek
  3. Model regresi untuk mengencangkan kotak pembatas.

Semua proses ini bergabung untuk membuat RCNN sangat lambat. Dibutuhkan sekitar 40-50 detik untuk membuat prediksi untuk setiap gambar baru, yang pada dasarnya membuat model menjadi rumit dan praktis tidak mungkin dibuat ketika dihadapkan dengan kumpulan data raksasa.

Inilah kabar baiknya – kita memiliki teknik pendeteksian objek lain yang memperbaiki sebagian besar keterbatasan RCNN.

 

3. Memahami Fast RCNN 

3.1 Intuisi Fast RCNN 

Apa lagi yang bisa kita lakukan untuk mengurangi waktu komputasi yang biasanya dibutuhkan oleh algoritma RCNN? Alih-alih menjalankan CNN 2.000 kali per gambar, kita dapat menjalankannya hanya sekali per gambar dan mendapatkan semua wilayah yang diinginkan (wilayah yang berisi beberapa objek).

Ross Girshick, penulis RCNN, muncul dengan ide menjalankan CNN hanya sekali per gambar dan kemudian menemukan cara untuk membagikan perhitungan itu di 2.000 wilayah. Di Fast RCNN, kami memasukkan gambar input ke CNN, yang pada gilirannya menghasilkan peta fitur konvolusi. Dengan menggunakan peta ini, wilayah proposal diekstraksi. Kemudian menggunakan lapisan penyatuan RoI untuk membentuk kembali semua wilayah yang diusulkan menjadi ukuran tetap, sehingga dapat dimasukkan ke dalam jaringan yang terhubung sepenuhnya.

Mari kita uraikan ini menjadi langkah-langkah untuk menyederhanakan konsep:

1. Seperti dua teknik sebelumnya, kita mengambil gambar sebagai input.
2. Gambar ini diteruskan ke ConvNet yang pada gilirannya menghasilkan Wilayah yang Diinginkan.
3. Lapisan penyatuan RoI diterapkan pada semua wilayah ini untuk membentuknya kembali sesuai dengan input ConvNet. Kemudian, setiap wilayah diteruskan ke jaringan yang sepenuhnya terhubung.
4. Lapisan softmax digunakan di atas jaringan yang sepenuhnya terhubung ke kelas output. Seiring dengan lapisan softmax, lapisan regresi linier juga digunakan secara paralel untuk menghasilkan koordinat kotak pembatas untuk kelas yang diprediksi.
   

Jadi, alih-alih menggunakan tiga model berbeda (seperti di RCNN), Fast RCNN menggunakan model tunggal yang mengekstrak fitur dari wilayah, membaginya ke dalam kelas yang berbeda, dan mengembalikan kotak batas untuk kelas yang diidentifikasi secara bersamaan.

Untuk memecah ini lebih jauh, saya akan memvisualisasikan setiap langkah untuk menambahkan sudut praktis pada penjelasannya.

• Kami mengikuti langkah yang sekarang terkenal untuk mengambil gambar sebagai input:
  
• Gambar ini diteruskan ke ConvNet yang mengembalikan wilayah minat yang sesuai:
  
• Kemudian kami menerapkan lapisan penyatuan RoI pada wilayah yang diekstraksi untuk memastikan semua wilayah memiliki ukuran yang sama:
  
• Akhirnya, wilayah ini diteruskan ke jaringan yang sepenuhnya terhubung yang mengklasifikasikannya, serta mengembalikan kotak pembatas menggunakan softmax dan lapisan regresi linier secara bersamaan:
  

Beginilah cara Fast RCNN menyelesaikan dua masalah utama RCNN, yaitu, meneruskan satu alih-alih 2.000 wilayah per gambar ke ConvNet, dan menggunakan satu alih-alih tiga model berbeda untuk mengekstraksi fitur, klasifikasi, dan menghasilkan kotak pembatas.

 

3.2 Masalah dengan Fast RCNN 

Tetapi bahkan Fast RCNN memiliki area masalah tertentu. Ini juga menggunakan pencarian selektif sebagai metode proposal untuk menemukan Wilayah yang Diinginkan, yang merupakan proses yang lambat dan memakan waktu. Dibutuhkan sekitar 2 detik per gambar untuk mendeteksi objek, yang jauh lebih baik dibandingkan dengan RCNN. Tetapi ketika mempertimbangkan kumpulan data kehidupan nyata yang besar, bahkan Fast RCNN tidak terlihat begitu cepat lagi.

Tapi ada algoritma pendeteksi objek lain yang mengalahkan Fast RCNN: Faster RCNN. 

 

4. Memahami Faster RCNN 

4.1. Intuisi Faster RCNN

Faster RCNN adalah versi modifikasi dari Fast RCNN. Perbedaan utama di antara mereka adalah Fast RCNN menggunakan pencarian selektif untuk menghasilkan Regions of Interest, sedangkan Faster RCNN menggunakan "Region Proposal Network", alias RPN. RPN mengambil peta fitur gambar sebagai input dan menghasilkan satu set proposal objek, masing-masing dengan skor objektivitas sebagai output.

Langkah-langkah di bawah ini biasanya diikuti dalam pendekatan RCNN yang Lebih Cepat:

1. Mengambil gambar sebagai input dan meneruskannya ke ConvNet yang mengembalikan peta fitur untuk gambar itu.
2. Jaringan proposal wilayah diterapkan pada peta fitur ini. Ini mengembalikan proposal objek bersama dengan skor objektivitasnya.
3. Lapisan penyatuan RoI diterapkan pada proposal ini untuk menurunkan semua proposal ke ukuran yang sama.
4. Akhirnya, proposal diteruskan ke lapisan yang terhubung penuh yang memiliki lapisan softmax dan lapisan regresi linier di atasnya, untuk mengklasifikasikan dan menampilkan kotak pembatas untuk objek.

Bagaimana Jaringan Proposal Wilayah (RPN) ini bekerja?

Untuk memulainya, Faster RCNN mengambil peta fitur dari CNN dan meneruskannya ke Jaringan Proposal Wilayah (Region Proposal Network). RPN menggunakan sliding windowr di setiap peta fitur, dan di setiap jendela, ini menghasilkan k Anchor boxes dengan berbagai bentuk dan ukuran:

Anchor boxes adalah kotak batas berukuran tetap yang ditempatkan di seluruh gambar dan memiliki bentuk dan ukuran yang berbeda. Untuk setiap anchor, RPN memprediksi dua hal:

• Yang pertama adalah probabilitas bahwaAnchor box adalah objek (tidak mempertimbangkan kelas mana objek itu berasal)
• Kedua adalah regressor kotak pembatas untuk menyesuaikan Anchor boxes agar lebih sesuai dengan objek

Kita sekarang memiliki kotak pembatas dengan berbagai bentuk dan ukuran yang diteruskan ke lapisan penyatuan RoI. Sekarang mungkin saja setelah langkah RPN, ada proposal tanpa kelas yang ditugaskan padanya. Kita dapat mengambil setiap proposal dan memotongnya sehingga setiap proposal berisi objek. Inilah yang dilakukan lapisan penyatuan RoI. Ini mengekstrak peta fitur berukuran tetap untuk setiap Anchor boxes:

Kemudian peta fitur ini diteruskan ke lapisan yang terhubung penuh yang memiliki lapisan softmax dan regresi linier. Akhirnya mengklasifikasikan objek dan memprediksi kotak pembatas untuk objek yang diidentifikasi.

 

4.2 Masalah dengan RCNN yang Lebih Cepat

Semua algoritma deteksi objek yang telah kita bahas sejauh ini menggunakan wilayah untuk mengidentifikasi objek. Jaringan tidak melihat gambar lengkap sekaligus, tetapi berfokus pada bagian-bagian gambar secara berurutan. Ini menciptakan dua komplikasi:

• Algoritma membutuhkan banyak lintasan melalui satu gambar untuk mengekstrak semua objek
• Karena ada sistem berbeda yang bekerja satu demi satu, kinerja sistem lebih jauh ke depan tergantung pada bagaimana kinerja sistem sebelumnya

 

5. Ringkasan Algoritma yang dibahas

Tabel di bawah ini adalah ringkasan bagus dari semua algoritma yang telah di bahas dalam artikel ini. 

algoritma	Fitur	Prediksi waktu / gambar	Keterbatasan
CNN	Membagi citra menjadi beberapa region kemudian mengklasifikasikan setiap region ke dalam berbagai kelas.	-	Membutuhkan banyak wilayah untuk memprediksi secara akurat dan karenanya waktu komputasi yang tinggi.
RCNN	Menggunakan pencarian selektif untuk menghasilkan wilayah. Ekstrak sekitar 2000 wilayah dari setiap gambar.	40-50 detik	Waktu komputasi yang tinggi karena setiap region dilewatkan ke CNN secara terpisah serta menggunakan tiga model yang berbeda untuk membuat prediksi.
Fast RCNN	Setiap gambar dilewatkan hanya sekali ke CNN dan peta fitur diekstraksi. Pencarian selektif digunakan pada peta ini untuk menghasilkan prediksi. Menggabungkan ketiga model yang digunakan dalam RCNN bersama-sama.	2 detik	Pencarian selektif lambat dan karenanya waktu komputasi masih tinggi.
Faster RCNN	Mengganti metode pencarian selektif dengan jaringan proposal wilayah yang membuat algoritme lebih cepat.	0,2 detik	Proposal objek membutuhkan waktu dan karena ada sistem yang berbeda yang bekerja satu demi satu, kinerja sistem tergantung pada kinerja sistem sebelumnya.