Deteksi objek menggunakan Fast R-CNN

Daftar Isi

Ringkasan

gambar gambar

Tutorial ini menjelaskan cara menggunakan Fast R-CNN di CNTK Python API. R-CNN cepat menggunakan BrainScript dan cnkt.exe dijelaskan di sini.

Di atas adalah contoh gambar dan anotasi objek untuk himpunan data kelontong (kiri) dan himpunan data VOC Pascal (kanan) yang digunakan dalam tutorial ini.

Fast R-CNN adalah algoritma deteksi objek yang diusulkan oleh Ross Girshick pada tahun 2015. Makalah diterima untuk ICCV 2015, dan diarsipkan di https://arxiv.org/abs/1504.08083. R-CNN cepat dibangun pada pekerjaan sebelumnya untuk mengklasifikasikan proposal objek secara efisien menggunakan jaringan konvolusional yang mendalam. Dibandingkan dengan pekerjaan sebelumnya, Fast R-CNN menggunakan skema pengumpulan wilayah yang menarik yang memungkinkan untuk menggunakan kembali komputasi dari lapisan konvolusional.

Siapkan

Untuk menjalankan kode dalam contoh ini, Anda memerlukan lingkungan CNTK Python (lihat di sini untuk bantuan penyiapan). Harap instal paket tambahan berikut di lingkungan Python cntk Anda

pip install opencv-python easydict pyyaml dlib

Biner yang telah dikompilasi sebelumnya untuk regresi kotak pembatas dan penekanan non maksimum

Folder Examples\Image\Detection\utils\cython_modules berisi biner yang telah dikompilasi sebelumnya yang diperlukan untuk menjalankan Fast R-CNN. Versi yang saat ini terkandung dalam repositori adalah Python 3.5 untuk Windows dan Python 3.5, 3.6 untuk Linux, semua 64 bit. Jika Anda memerlukan versi yang berbeda, Anda dapat mengkompilasinya dengan mengikuti langkah-langkah yang dijelaskan di

Salin biner yang dihasilkan cython_bbox dan cpu_nms (dan/atau gpu_nms) dari $FRCN_ROOT/lib/utils ke $CNTK_ROOT/Examples/Image/Detection/utils/cython_modules.

Contoh data dan model garis besar

Kami menggunakan model AlexNet yang telah dilatih sebelumnya sebagai dasar untuk pelatihan Fast-R-CNN (untuk VGG atau model dasar lainnya lihat Menggunakan model dasar yang berbeda. Contoh himpunan data dan model AlexNet yang telah dilatih sebelumnya dapat diunduh dengan menjalankan perintah Python berikut dari folder FastRCNN:

python install_data_and_model.py

Jalankan contoh mainan

Untuk melatih dan mengevaluasi eksekusi Fast R-CNN

python run_fast_rcnn.py

Hasil untuk pelatihan dengan 2000 ROI di Grocery menggunakan AlexNet sebagai model dasar akan terlihat mirip dengan ini:

AP for          gerkin = 1.0000
AP for          butter = 1.0000
AP for         joghurt = 1.0000
AP for          eggBox = 1.0000
AP for         mustard = 1.0000
AP for       champagne = 1.0000
AP for          orange = 1.0000
AP for           water = 0.5000
AP for         avocado = 1.0000
AP for          tomato = 1.0000
AP for          pepper = 1.0000
AP for         tabasco = 1.0000
AP for           onion = 1.0000
AP for            milk = 1.0000
AP for         ketchup = 0.6667
AP for     orangeJuice = 1.0000
Mean AP = 0.9479

Untuk memvisualisasikan kotak dan label pembatas yang diprediksi pada gambar yang terbuka FastRCNN_config.py dari FastRCNN folder dan mengatur

__C.VISUALIZE_RESULTS = True

Gambar akan disimpan ke FastRCNN/Output/Grocery/ dalam folder jika Anda menjalankan python run_fast_rcnn.py.

Berlatih di Pascal VOC

Untuk mengunduh data Pascal dan membuat file anotasi untuk Pascal dalam format CNTK, jalankan skrip berikut:

python Examples/Image/DataSets/Pascal/install_pascalvoc.py
python Examples/Image/DataSets/Pascal/mappings/create_mappings.py

dataset_cfg Ubah dalam get_configuration() metode menjadi run_fast_rcnn.py

from utils.configs.Pascal_config import cfg as dataset_cfg

Sekarang Anda diatur untuk berlatih pada data Pascal VOC 2007 menggunakan python run_fast_rcnn.py. Berhati-hatilah bahwa pelatihan mungkin memakan waktu cukup lama.

Melatih data Anda sendiri

Menyiapkan himpunan data kustom

Opsi #1: Alat Pemberian Tag Objek Visual (Disarankan)

Alat Pemberian Tag Objek Visual (VOTT) adalah alat anotasi lintas platform untuk menandai aset video dan gambar.

Cuplikan Layar Vott

VOTT menyediakan fitur-fitur berikut:

  • Penandaan dan pelacakan objek yang dibantu komputer dalam video menggunakan algoritma pelacakan Camshift.
  • Mengekspor tag dan aset ke format CNTK Fast-RCNN untuk melatih model deteksi objek.
  • Menjalankan dan memvalidasi model deteksi objek CNTK terlatih pada video baru untuk menghasilkan model yang lebih kuat.

Cara membuat anotasi dengan VOTT:

  1. Unduh Rilis terbaru
  2. Ikuti Readme untuk menjalankan pekerjaan pemberian tag
  3. Setelah menandai tag Ekspor ke direktori himpunan data

Opsi #2: Menggunakan Skrip Anotasi

Untuk melatih model CNTK Fast R-CNN pada himpunan data Anda sendiri, kami menyediakan dua skrip untuk membuat anotasi wilayah persegi panjang pada gambar dan menetapkan label ke wilayah ini. Skrip akan menyimpan anotasi dalam format yang benar seperti yang diperlukan oleh langkah pertama menjalankan Fast R-CNN (A1_GenerateInputROIs.py). Pertama, simpan gambar Anda dalam struktur folder berikut

  • <your_image_folder>/negative - gambar yang digunakan untuk pelatihan yang tidak berisi objek apa pun
  • <your_image_folder>/positive - gambar yang digunakan untuk pelatihan yang berisi objek
  • <your_image_folder>/testImages - gambar yang digunakan untuk pengujian yang memang berisi objek

Untuk gambar negatif, Anda tidak perlu membuat anotasi apa pun. Untuk dua folder lainnya, gunakan skrip yang disediakan:

  • Jalankan C1_DrawBboxesOnImages.py untuk menggambar kotak pembatas pada gambar.
    • Dalam set imgDir = <your_image_folder> skrip (/positive atau /testImages) sebelum berjalan.
    • Tambahkan anotasi menggunakan kursor mouse. Setelah semua objek dalam gambar diannotasi, menekan tombol 'n' menulis file .bboxes.txt dan kemudian melanjutkan ke gambar berikutnya, 'u' membatalkan (yaitu menghapus) persegi panjang terakhir, dan 'q' keluar dari alat anotasi.
  • Jalankan C2_AssignLabelsToBboxes.py untuk menetapkan label ke kotak pembatas.
    • Dalam set imgDir = <your_image_folder> skrip (/positive atau /testImages) sebelum menjalankan...
    • ... dan sesuaikan kelas dalam skrip untuk mencerminkan kategori objek Anda, misalnya classes = ("dog", "cat", "octopus").
    • Skrip memuat persegi panjang yang diannotasi secara manual ini untuk setiap gambar, menampilkannya satu per satu, dan meminta pengguna untuk menyediakan kelas objek dengan mengklik tombol masing-masing di sebelah kiri jendela. Anotasi kebenaran dasar yang ditandai sebagai "tidak terdeteksi" atau "dikecualikan" sepenuhnya dikecualikan dari pemrosesan lebih lanjut.

Melatih himpunan data kustom

Setelah menyimpan gambar Anda dalam struktur folder yang dijelaskan dan membuat anotasi, silakan jalankan

python Examples/Image/Detection/utils/annotations/annotations_helper.py

setelah mengubah folder dalam skrip tersebut ke folder data Anda. Terakhir, buat MyDataSet_config.py di utils\configs folder dengan mengikuti contoh yang ada:

__C.CNTK.DATASET == "YourDataSet":
__C.CNTK.MAP_FILE_PATH = "../../DataSets/YourDataSet"
__C.CNTK.CLASS_MAP_FILE = "class_map.txt"
__C.CNTK.TRAIN_MAP_FILE = "train_img_file.txt"
__C.CNTK.TEST_MAP_FILE = "test_img_file.txt"
__C.CNTK.TRAIN_ROI_FILE = "train_roi_file.txt"
__C.CNTK.TEST_ROI_FILE = "test_roi_file.txt"
__C.CNTK.NUM_TRAIN_IMAGES = 500
__C.CNTK.NUM_TEST_IMAGES = 200
__C.CNTK.PROPOSAL_LAYER_SCALES = [8, 16, 32]

Perhatikan bahwa __C.CNTK.PROPOSAL_LAYER_SCALES tidak digunakan untuk R-CNN Cepat, hanya untuk R-CNN Yang Lebih Cepat.

Untuk melatih dan mengevaluasi Fast R-CNN pada data Anda, ubah dataset_cfg dalam get_configuration() metode menjadi run_fast_rcnn.py

from utils.configs.MyDataSet_config import cfg as dataset_cfg

dan jalankan python run_fast_rcnn.py.

Detail teknis

Algoritma Fast R-CNN dijelaskan di bagian Detail algoritma bersama dengan gambaran umum tingkat tinggi tentang bagaimana hal itu diimplementasikan dalam CNTK Python API. Bagian ini berfokus pada konfigurasi R-CNN Cepat dan cara Anda menggunakan model dasar yang berbeda.

Parameter

Parameter dikelompokkan menjadi tiga bagian:

  • Parameter detektor (lihat FastRCNN/FastRCNN_config.py)
  • Parameter himpunan data (lihat misalnya utils/configs/Grocery_config.py)
  • Parameter model dasar (lihat misalnya utils/configs/AlexNet_config.py)

Tiga bagian dimuat dan digabungkan get_configuration() dalam metode di run_fast_rcnn.py. Di bagian ini kita akan membahas parameter detektor. Parameter himpunan data dijelaskan di sini, parameter model dasar di sini. Dalam hal berikut ini kita melalui parameter yang paling penting di FastRCNN_config.py. Semua parameter juga dikomentari dalam file. Konfigurasi menggunakan paket yang memungkinkan akses mudah ke kamus EasyDict berlapis.

# Number of regions of interest [ROIs] proposals
__C.NUM_ROI_PROPOSALS = 200 # use 2000 or more for good results
# the minimum IoU (overlap) of a proposal to qualify for training regression targets
__C.BBOX_THRESH = 0.5

# Maximum number of ground truth annotations per image
__C.INPUT_ROIS_PER_IMAGE = 50
__C.IMAGE_WIDTH = 850
__C.IMAGE_HEIGHT = 850

# Use horizontally-flipped images during training?
__C.TRAIN.USE_FLIPPED = True
# If set to 'True' conv layers weights from the base model will be trained, too
__C.TRAIN_CONV_LAYERS = True

Proposal ROI dihitung dengan cepat di epoch pertama menggunakan implementasi pencarian selektif dari dlib paket. Jumlah proposal yang dihasilkan dikendalikan oleh __C.NUM_ROI_PROPOSALS parameter . Sebaiknya gunakan sekitar 2000 proposal. Kepala regresi hanya dilatih pada ROI yang memiliki tumpang tindih (IoU) dengan kotak kebenaran dasar setidaknya __C.BBOX_THRESH.

__C.INPUT_ROIS_PER_IMAGE menentukan jumlah maksimum anotasi kebenaran dasar per gambar. CNTK saat ini perlu mengatur angka maksimum. Jika ada lebih sedikit anotasi, anotasi akan di-padding secara internal. __C.IMAGE_WIDTH dan __C.IMAGE_HEIGHT merupakan dimensi yang digunakan untuk mengubah ukuran dan pad gambar input.

__C.TRAIN.USE_FLIPPED = True akan menambah data pelatihan dengan membalik semua gambar setiap masa lainnya, yaitu epoch pertama memiliki semua gambar biasa, yang kedua memiliki semua gambar yang dibalik, dan sebagainya. __C.TRAIN_CONV_LAYERS menentukan apakah lapisan konvolusional, dari input ke peta fitur konvolusional, akan dilatih atau diperbaiki. Memperbaiki bobot lapisan conv berarti bahwa bobot dari model dasar diambil dan tidak dimodifikasi selama pelatihan. (Anda juga dapat menentukan berapa banyak lapisan conv yang ingin Anda latih, lihat bagian Menggunakan model dasar yang berbeda).

# NMS threshold used to discard overlapping predicted bounding boxes
__C.RESULTS_NMS_THRESHOLD = 0.5

# If set to True the following two parameters need to point to the corresponding files that contain the proposals:
# __C.DATA.TRAIN_PRECOMPUTED_PROPOSALS_FILE
# __C.DATA.TEST_PRECOMPUTED_PROPOSALS_FILE
__C.USE_PRECOMPUTED_PROPOSALS = False

__C.RESULTS_NMS_THRESHOLD adalah ambang NMS yang digunakan untuk membuang kotak pembatas yang diprediksi tumpang tindih dalam evaluasi. Ambang batas yang lebih rendah menghasilkan lebih sedikit penghapusan dan karenanya kotak pembatas yang lebih diprediksi dalam output akhir. Jika Anda mengatur __C.USE_PRECOMPUTED_PROPOSALS = True pembaca akan membaca ROI yang telah dikomputasi sebelumnya dari file teks. Ini misalnya digunakan untuk pelatihan tentang data Pascal VOC. Nama __C.DATA.TRAIN_PRECOMPUTED_PROPOSALS_FILE file dan __C.DATA.TEST_PRECOMPUTED_PROPOSALS_FILE ditentukan dalam Examples/Image/Detection/utils/configs/Pascal_config.py.

# The basic segmentation is performed kvals.size() times. The k parameter is set (from, to, step_size)
__C.roi_ss_kvals = (10, 500, 5)
# When doing the basic segmentations prior to any box merging, all
# rectangles that have an area < min_size are discarded. Therefore, all outputs and
# subsequent merged rectangles are built out of rectangles that contain at
# least min_size pixels. Note that setting min_size to a smaller value than
# you might otherwise be interested in using can be useful since it allows a
# larger number of possible merged boxes to be created
__C.roi_ss_min_size = 9
# There are max_merging_iterations rounds of neighboring blob merging.
# Therefore, this parameter has some effect on the number of output rectangles
# you get, with larger values of the parameter giving more output rectangles.
# Hint: set __C.CNTK.DEBUG_OUTPUT=True to see the number of ROIs from selective search
__C.roi_ss_mm_iterations = 30
# image size used for ROI generation
__C.roi_ss_img_size = 200

Parameter di atas mengonfigurasi pencarian selektif dlib. Untuk detailnya, lihat beranda dlib. Parameter tambahan berikut digunakan untuk memfilter ROIs yang dihasilkan w.r.t. panjang sisi minimum dan maksimum, rasio area dan aspek.

# minimum relative width/height of an ROI
__C.roi_min_side_rel = 0.01
# maximum relative width/height of an ROI
__C.roi_max_side_rel = 1.0
# minimum relative area of an ROI
__C.roi_min_area_rel = 0.0001
# maximum relative area of an ROI
__C.roi_max_area_rel = 0.9
# maximum aspect ratio of an ROI vertically and horizontally
__C.roi_max_aspect_ratio = 4.0
# aspect ratios of ROIs for uniform grid ROIs
__C.roi_grid_aspect_ratios = [1.0, 2.0, 0.5]

Jika pencarian selektif mengembalikan lebih banyak ROI daripada yang diminta, pencarian tersebut diambil sampelnya secara acak. Jika lebih sedikit ROI yang mengembalikan ROI tambahan dihasilkan pada kisi reguler menggunakan yang ditentukan __C.roi_grid_aspect_ratios.

Menggunakan model dasar yang berbeda

Untuk menggunakan model dasar yang berbeda, Anda perlu memilih konfigurasi model yang berbeda dalam get_configuration() metode run_fast_rcnn.py. Dua model segera didukung:

    # for VGG16 base model use:         from utils.configs.VGG16_config import cfg as network_cfg
    # for AlexNet base model use:       from utils.configs.AlexNet_config import cfg as network_cfg

Untuk mengunduh model VGG16, silakan gunakan skrip unduhan di <cntkroot>/PretrainedModels:

    python download_model.py VGG16_ImageNet_Caffe

Jika Anda ingin menggunakan model dasar lain yang berbeda, Anda perlu menyalin, misalnya, file utils/configs/VGG16_config.py konfigurasi dan memodifikasinya sesuai dengan model dasar Anda:

# model config
__C.MODEL.BASE_MODEL = "VGG16"
__C.MODEL.BASE_MODEL_FILE = "VGG16_ImageNet_Caffe.model"
__C.MODEL.IMG_PAD_COLOR = [103, 116, 123]
__C.MODEL.FEATURE_NODE_NAME = "data"
__C.MODEL.LAST_CONV_NODE_NAME = "relu5_3"
__C.MODEL.START_TRAIN_CONV_NODE_NAME = "pool2" # __C.MODEL.FEATURE_NODE_NAME
__C.MODEL.POOL_NODE_NAME = "pool5"
__C.MODEL.LAST_HIDDEN_NODE_NAME = "drop7"
__C.MODEL.FEATURE_STRIDE = 16
__C.MODEL.RPN_NUM_CHANNELS = 512
__C.MODEL.ROI_DIM = 7

Untuk menyelidiki nama node model dasar Anda, Anda dapat menggunakan plot() metode dari cntk.logging.graph. Harap dicatat bahwa model ResNet saat ini tidak didukung karena pengumpulan roi di CNTK belum mendukung pengumpulan rata-rata roi.

Detail algoritma

R-CNN cepat

R-CN untuk Deteksi Objek pertama kali disajikan pada tahun 2014 oleh Ross Girshick et al., dan terbukti mengungguli pendekatan canggih sebelumnya pada salah satu tantangan pengenalan objek utama di bidang: Pascal VOC. Sejak itu, dua makalah tindak lanjut diterbitkan yang berisi peningkatan kecepatan yang signifikan: R-CNN Cepat dan R-CNN Yang Lebih Cepat.

Ide dasar R-CNN adalah untuk mengambil Jaringan Neural mendalam yang awalnya dilatih untuk klasifikasi gambar menggunakan jutaan gambar anotasi dan memodifikasinya untuk tujuan deteksi objek. Ide dasar dari makalah R-CNN pertama diilustrasikan dalam Gambar di bawah ini (diambil dari makalah): (1) Mengingat gambar input, (2) pada langkah pertama, proposal wilayah dalam jumlah besar dihasilkan. (3) Proposal wilayah ini, atau Regions-of-Interests (ROI), kemudian masing-masing dikirim secara independen melalui jaringan yang menghasilkan vektor misalnya 4096 nilai floating point untuk setiap ROI. Akhirnya, (4) pengklasifikasi dipelajari yang mengambil representasi ROI float 4096 sebagai input dan menghasilkan label dan keyakinan untuk setiap ROI.

gambar

Meskipun pendekatan ini bekerja dengan baik dalam hal akurasi, sangat mahal untuk menghitung karena Jaringan Neural harus dievaluasi untuk setiap ROI. R-CNN cepat mengatasi kelemahan ini hanya dengan mengevaluasi sebagian besar jaringan (khususnya: lapisan konvolusi) satu kali per gambar. Menurut penulis, ini menyebabkan kecepatan 213 kali selama pengujian dan kecepatan 9x selama pelatihan tanpa kehilangan akurasi. Ini dicapai dengan menggunakan lapisan pengumpulan ROI yang memproyeksikan ROI ke peta fitur konvolusional dan melakukan pengumpulan maks untuk menghasilkan ukuran output yang diinginkan yang diharapkan lapisan berikut. Dalam contoh AlexNet yang digunakan dalam tutorial ini, lapisan pengumpulan ROI diletakkan di antara lapisan konvolusional terakhir dan lapisan pertama yang sepenuhnya terhubung. Dalam kode API Python CNTK yang ditunjukkan di bawah ini diwujudkan dengan mengkloning dua bagian jaringan, conv_layers dan fc_layers. Gambar input kemudian pertama kali dinormalisasi, didorong melalui conv_layers, roipooling lapisan dan dan fc_layers akhirnya kepala prediksi dan regresi ditambahkan yang memprediksi label kelas dan koefisien regresi per kandidat ROI masing-masing.

def create_fast_rcnn_model(features, roi_proposals, label_targets, bbox_targets, bbox_inside_weights, cfg):
    # Load the pre-trained classification net and clone layers
    base_model = load_model(cfg['BASE_MODEL_PATH'])
    conv_layers = clone_conv_layers(base_model, cfg)
    fc_layers = clone_model(base_model, [cfg["MODEL"].POOL_NODE_NAME], [cfg["MODEL"].LAST_HIDDEN_NODE_NAME], clone_method=CloneMethod.clone)

    # Normalization and conv layers
    feat_norm = features - Constant([[[v]] for v in cfg["MODEL"].IMG_PAD_COLOR])
    conv_out = conv_layers(feat_norm)

    # Fast RCNN and losses
    cls_score, bbox_pred = create_fast_rcnn_predictor(conv_out, roi_proposals, fc_layers, cfg)
    detection_losses = create_detection_losses(...)
    pred_error = classification_error(cls_score, label_targets, axis=1)

    return detection_losses, pred_error

def create_fast_rcnn_predictor(conv_out, rois, fc_layers, cfg):
    # RCNN
    roi_out = roipooling(conv_out, rois, cntk.MAX_POOLING, (6, 6), spatial_scale=1/16.0)
    fc_out = fc_layers(roi_out)

    # prediction head
    cls_score = plus(times(fc_out, W_pred), b_pred, name='cls_score')

    # regression head
    bbox_pred = plus(times(fc_out, W_regr), b_regr, name='bbox_regr')

    return cls_score, bbox_pred

Implementasi Caffe asli yang digunakan dalam makalah R-CNN dapat ditemukan di GitHub: RCNN, Fast R-CNN, dan Faster R-CNN.

Pelatihan SVM vs NN

Patrick Buehler memberikan instruksi tentang cara melatih SVM pada output CNTK Fast R-CNN (menggunakan fitur 4096 dari lapisan terakhir yang sepenuhnya terhubung) serta diskusi tentang pro dan kontra di sini.

Pencarian Selektif adalah metode untuk menemukan sekumpulan besar lokasi objek yang mungkin dalam gambar, terlepas dari kelas objek aktual. Ini bekerja dengan mengklusterkan piksel gambar ke dalam segmen, dan kemudian melakukan pengklusteran hierarkis untuk menggabungkan segmen dari objek yang sama ke dalam proposal objek.

gambargambar gambar

Untuk melengkapi ROI yang terdeteksi dari Pencarian Selektif, kami menambahkan ROI yang seragam mencakup gambar pada skala dan rasio aspek yang berbeda. Gambar di sebelah kiri menunjukkan contoh output Pencarian Selektif, di mana setiap lokasi objek yang mungkin divisualisasikan oleh persegi panjang hijau. ROI yang terlalu kecil, terlalu besar, dll dibuang (tengah) dan akhirnya ROI yang secara seragam menutupi gambar ditambahkan (kanan). Persegi panjang ini kemudian digunakan sebagai Regions-of-Interests (ROI) dalam alur R-CNN.

Tujuan dari generasi ROI adalah untuk menemukan sekumpulan kecil ROI yang bagaimanapun menutupi sebanyak mungkin objek dalam gambar. Komputasi ini harus cukup cepat, sementara pada saat yang sama menemukan lokasi objek pada skala dan rasio aspek yang berbeda. Pencarian Selektif terbukti berkinerja baik untuk tugas ini, dengan akurasi yang baik untuk mempercepat trade-off.

NMS (Supresi Non Maksimum)

Metode deteksi objek sering menghasilkan beberapa deteksi yang sepenuhnya atau sebagian mencakup objek yang sama dalam gambar. ROI ini perlu digabungkan untuk dapat menghitung objek dan mendapatkan lokasi yang tepat dalam gambar. Ini secara tradisional dilakukan menggunakan teknik yang disebut Non Maximum Suppression (NMS). Versi NMS yang kami gunakan (dan yang juga digunakan dalam publikasi R-CNN) tidak menggabungkan ROI tetapi mencoba mengidentifikasi ROI mana yang paling baik mencakup lokasi nyata objek dan membuang semua ROI lainnya. Ini diimplementasikan dengan secara berulang memilih ROI dengan keyakinan tertinggi dan menghapus semua ROI lain yang secara signifikan tumpang tindih dengan ROI ini dan diklasifikasikan untuk berada di kelas yang sama. Ambang batas untuk tumpang tindih dapat diatur dalam PARAMETERS.py (detail).

Hasil deteksi sebelum (kiri) dan setelah (kanan) Supresi Non Maksimum:

gambar gambar

mAP (rata-rata Presisi Rata-Rata)

Setelah dilatih, kualitas model dapat diukur menggunakan kriteria yang berbeda, seperti presisi, pengenalan, akurasi, area-di bawah kurva, dll. Metrik umum yang digunakan untuk tantangan pengenalan objek Pascal VOC adalah mengukur Presisi Rata-Rata (AP) untuk setiap kelas. Deskripsi Presisi Rata-Rata berikut diambil dari Everingham dkk. Rata-rata Presisi Rata-Rata (mAP) dihitung dengan mengambil rata-rata atas IP semua kelas.

Untuk tugas dan kelas tertentu, kurva presisi/pengenalan dihitung dari output berperingkat metode. Pengenalan didefinisikan sebagai proporsi dari semua contoh positif yang diberi peringkat di atas peringkat tertentu. Presisi adalah proporsi semua contoh di atas peringkat tersebut yang berasal dari kelas positif. AP merangkum bentuk kurva presisi/pengenalan, dan didefinisikan sebagai presisi rata-rata pada satu set sebelas tingkat pengenalan yang sama spasi [0,0,1, . . . ,1]:

gambar

Presisi pada setiap tingkat pengenalan r diinterpolasi dengan mengambil presisi maksimum yang diukur untuk metode yang pengenalan yang sesuai melebihi r:

gambar

dimana p( ̃r) adalah presisi yang diukur pada pengenalan ̃r. Niat dalam menginterpolasi kurva presisi/pengenalan dengan cara ini adalah untuk mengurangi dampak "menggoyangkan" dalam kurva presisi/pengenalan, yang disebabkan oleh variasi kecil dalam peringkat contoh. Perlu dicatat bahwa untuk mendapatkan skor tinggi, metode harus memiliki presisi di semua tingkat pengenalan - ini mengharuskan metode yang hanya mengambil subset contoh dengan presisi tinggi (misalnya tampilan samping mobil).

  • Last updated on