Delen via

Objectdetectie met Fast R-CNN

Inhoudsopgave

Samenvatting

afbeelding van afbeelding

In deze zelfstudie wordt beschreven hoe u Fast R-CNN gebruikt in de CNTK Python-API. Fast R-CNN met behulp van BrainScript en cnkt.exe wordt hier beschreven.

De bovenstaande voorbeelden zijn afbeeldingen en objectaantekeningen voor de boodschappengegevensset (links) en de Pascal VOC-gegevensset (rechts) die in deze zelfstudie worden gebruikt.

Fast R-CNN is een algoritme voor objectdetectie dat wordt voorgesteld door Ross Girshick in 2015. Het document wordt geaccepteerd bij ICCV 2015 en gearchiveerd op https://arxiv.org/abs/1504.08083. Fast R-CNN bouwt voort op het vorige werk om objectvoorstellen efficiënt te classificeren met behulp van diepe convolutionele netwerken. In vergelijking met het vorige werk maakt Fast R-CNN gebruik van een poolschema voor interesse waarmee de berekeningen uit de convolutionele lagen opnieuw kunnen worden gebruikt.

Instellen

Als u de code in dit voorbeeld wilt uitvoeren, hebt u een CNTK Python-omgeving nodig ( zie hier voor hulp bij het instellen). Installeer de volgende aanvullende pakketten in uw cntk Python-omgeving

pip install opencv-python easydict pyyaml dlib

Vooraf gecompileerde binaire bestanden voor regressie van begrenzingsvak en niet-maximale onderdrukking

De map Examples\Image\Detection\utils\cython_modules bevat vooraf gecompileerde binaire bestanden die vereist zijn voor het uitvoeren van Fast R-CNN. De versies die zich momenteel in de opslagplaats bevinden, zijn Python 3.5 voor Windows en Python 3.5, 3.6 voor Linux, alle 64-bits. Als u een andere versie nodig hebt, kunt u deze compileren volgens de stappen die worden beschreven op

Kopieer de gegenereerde cython_bbox en cpu_nms (en/of gpu_nms) binaire bestanden van $FRCN_ROOT/lib/utils naar $CNTK_ROOT/Examples/Image/Detection/utils/cython_modules.

Voorbeeldgegevens en basislijnmodel

We gebruiken een vooraf getraind AlexNet-model als basis voor Fast-R-CNN-training (voor VGG of andere basismodellen zie Een ander basismodel gebruiken). Zowel de voorbeeldgegevensset als het vooraf getrainde AlexNet-model kunnen worden gedownload door de volgende Python-opdracht uit te voeren vanuit de map FastRCNN:

python install_data_and_model.py

Het speelgoedvoorbeeld uitvoeren

Fast R-CNN-uitvoering trainen en evalueren

python run_fast_rcnn.py

De resultaten voor het trainen met 2000 ROIs op Supermarkt met alexnet als het basismodel moeten er ongeveer als volgt uitzien:

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

De voorspelde begrenzingsvakken en labels op de afbeeldingen visualiseren die vanuit de FastRCNN map worden geopend FastRCNN_config.py en ingesteld

__C.VISUALIZE_RESULTS = True

De installatiekopieën worden opgeslagen in de FastRCNN/Output/Grocery/ map als u deze uitvoert python run_fast_rcnn.py.

Trainen op Pascal VOC

Voer de volgende scripts uit om de Pascal-gegevens te downloaden en de aantekeningenbestanden voor Pascal in CNTK-indeling te maken:

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

dataset_cfg De methode wijzigen run_fast_rcnn.py in get_configuration()

from utils.configs.Pascal_config import cfg as dataset_cfg

Nu bent u klaar om te trainen op de Pascal VOC 2007-gegevens met behulp van python run_fast_rcnn.py. Pas op dat het trainen even kan duren.

Trainen op uw eigen gegevens

Een aangepaste gegevensset voorbereiden

Optie 1: Hulpprogramma voor het taggen van visuele objecten (aanbevolen)

Het Visual Object Tagging Tool (VOTT) is een platformoverschrijdend hulpprogramma voor het taggen van video- en afbeeldingsassets.

Schermafbeelding van Vott

VOTT biedt de volgende functies:

  • Computergestuurd taggen en bijhouden van objecten in video's met behulp van het Camshift-tracking-algoritme.
  • Tags en assets exporteren naar CNTK Fast-RCNN-indeling voor het trainen van een objectdetectiemodel.
  • Het uitvoeren en valideren van een getraind CNTK-objectdetectiemodel op nieuwe video's om sterkere modellen te genereren.

Aantekeningen maken met VOTT:

  1. Download de nieuwste release
  2. Volg de leesmij om een tagtaak uit te voeren
  3. Na het taggen van tags exporteren naar de map van de gegevensset

Optie 2: Aantekeningenscripts gebruiken

Als u een CNTK Fast R-CNN-model wilt trainen op uw eigen gegevensset, bieden we twee scripts om aantekeningen te maken bij rechthoekige regio's op afbeeldingen en labels toe te wijzen aan deze regio's. De scripts slaan de aantekeningen op in de juiste indeling, zoals vereist voor de eerste stap van het uitvoeren van Fast R-CNN (A1_GenerateInputROIs.py). Sla eerst uw afbeeldingen op in de volgende mapstructuur

  • <your_image_folder>/negative - afbeeldingen die worden gebruikt voor training die geen objecten bevatten
  • <your_image_folder>/positive - afbeeldingen die worden gebruikt voor training die objecten bevatten
  • <your_image_folder>/testImages - afbeeldingen die worden gebruikt voor het testen van objecten

Voor de negatieve afbeeldingen hoeft u geen aantekeningen te maken. Gebruik voor de andere twee mappen de opgegeven scripts:

  • Voer deze opdracht uit C1_DrawBboxesOnImages.py om begrenzingsvakken op de afbeeldingen te tekenen.
    • In de scriptset imgDir = <your_image_folder> (/positive of /testImages) voordat deze wordt uitgevoerd.
    • Voeg aantekeningen toe met behulp van de muiscursor. Zodra alle objecten in een afbeelding zijn geannoteerd, schrijft u met de toets 'n' het .bboxes.txt-bestand en gaat u vervolgens verder met de volgende afbeelding. De laatste rechthoek wordt ongedaan gemaakt (d.w.w.v. wordt de laatste rechthoek verwijderd) en met 'q' wordt het hulpmiddel voor aantekeningen afgesloten.
  • Voer deze opdracht C2_AssignLabelsToBboxes.py uit om labels toe te wijzen aan de begrenzingsvakken.
    • In de scriptset imgDir = <your_image_folder> (/positive of /testImages) voordat deze wordt uitgevoerd...
    • ... en pas de klassen in het script aan zodat deze overeenkomen met uw objectcategorieën, bijvoorbeeld classes = ("dog", "cat", "octopus").
    • Het script laadt deze handmatig geannoteerde rechthoeken voor elke afbeelding, geeft deze één voor één weer en vraagt de gebruiker om de objectklasse op te geven door op de desbetreffende knop links van het venster te klikken. Annotaties van de grondwaar die zijn gemarkeerd als 'ongedecideerd' of 'uitsluiten' worden volledig uitgesloten van verdere verwerking.

Trainen op aangepaste gegevensset

Nadat u uw afbeeldingen hebt opgeslagen in de beschreven mapstructuur en er aantekeningen op hebt gemaakt, voert u deze uit

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

nadat u de map in dat script hebt gewijzigd in uw gegevensmap. Maak ten slotte een MyDataSet_config.py in de utils\configs map die volgt op de bestaande voorbeelden:

__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]

Houd er rekening mee dat __C.CNTK.PROPOSAL_LAYER_SCALES niet wordt gebruikt voor Fast R-CNN, alleen voor Snellere R-CNN.

Om Fast R-CNN te trainen en te evalueren op uw gegevens, wijzigt u de dataset_cfgget_configuration() methode van run_fast_rcnn.py

from utils.configs.MyDataSet_config import cfg as dataset_cfg

en voer uit python run_fast_rcnn.py.

Technische details

Het Fast R-CNN-algoritme wordt uitgelegd in de sectie Algoritmedetails , samen met een algemeen overzicht van hoe het wordt geïmplementeerd in de CNTK Python-API. Deze sectie is gericht op het configureren van Fast R-CNN en het gebruik van verschillende basismodellen.

Parameters

De parameters worden gegroepeerd in drie delen:

  • Detectorparameters (zie FastRCNN/FastRCNN_config.py)
  • Parameters voor gegevenssets (zie bijvoorbeeld utils/configs/Grocery_config.py)
  • Parameters basismodel (zie bijvoorbeeld utils/configs/AlexNet_config.py)

De drie onderdelen worden geladen en samengevoegd in de get_configuration() methode in run_fast_rcnn.py. In deze sectie behandelen we de detectorparameters. Hier worden parameters voor gegevenssets beschreven. Hier worden basismodelparameters beschreven. In het volgende gaan we door de belangrijkste parameters in FastRCNN_config.py. Alle parameters worden ook in het bestand gecommentarieerd. De configuratie maakt gebruik van het EasyDict pakket waarmee u eenvoudig toegang hebt tot geneste woordenlijsten.

# 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

De ROI-voorstellen worden in het eerste tijdvak berekend met behulp van de selectieve zoekimplementatie van het dlib pakket. Het aantal voorstellen dat wordt gegenereerd, wordt bepaald door de __C.NUM_ROI_PROPOSALS parameter. We raden u aan ongeveer 2000 voorstellen te gebruiken. De regressiekop wordt alleen getraind op die RO's die een overlap (IoU) hebben met een grondwaarvak van ten minste __C.BBOX_THRESH.

__C.INPUT_ROIS_PER_IMAGE hiermee geeft u het maximum aantal grondwaaraantekeningen per afbeelding. CNTK moet momenteel een maximum aantal instellen. Als er minder aantekeningen zijn, worden ze intern opgevuld. __C.IMAGE_WIDTH en __C.IMAGE_HEIGHT zijn de afmetingen die worden gebruikt om het formaat van de invoerafbeeldingen te wijzigen en op te vullingen.

__C.TRAIN.USE_FLIPPED = True zal de trainingsgegevens uitbreiden door alle afbeeldingen om de andere epoch te spiegelen, d.w.z. het eerste tijdvak bevat alle gewone afbeeldingen, de tweede heeft alle afbeeldingen gespiegeld, enzovoort. __C.TRAIN_CONV_LAYERS bepaalt of de convolutionele lagen, van invoer tot de toewijzing van convolutionele functies, worden getraind of opgelost. Als u de conv layer-gewichten vaststelt, betekent dit dat de gewichten van het basismodel worden genomen en niet worden gewijzigd tijdens de training. (U kunt ook opgeven hoeveel conv-lagen u wilt trainen, zie de sectie Een ander basismodel gebruiken).

# 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 is de NMS-drempelwaarde die wordt gebruikt om overlappende voorspelde begrenzingsvakken in evaluatie te verwijderen. Een lagere drempelwaarde levert minder verwijderingen op en dus meer voorspelde begrenzingsvakken in de uiteindelijke uitvoer. Als u de lezer instelt __C.USE_PRECOMPUTED_PROPOSALS = True , worden vooraf samengestelde URI's uit tekstbestanden gelezen. Dit wordt bijvoorbeeld gebruikt voor het trainen van Pascal VOC-gegevens. De bestandsnamen __C.DATA.TRAIN_PRECOMPUTED_PROPOSALS_FILE en __C.DATA.TEST_PRECOMPUTED_PROPOSALS_FILE worden opgegeven in 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

De bovenstaande parameters configureren selectief zoeken van dlib. Zie de dlib-startpagina voor meer informatie. De volgende aanvullende parameters worden gebruikt voor het filteren van gegenereerde URI's w.r.t. minimum- en maximumlengte, vlak- en hoogte-breedteverhouding.

# 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]

Als selectief zoeken meer URI's retourneert dan aangevraagd, worden ze willekeurig gesampleerd. Als er minder URI's worden geretourneerd, worden er extra URI's gegenereerd in een normaal raster met behulp van de opgegeven __C.roi_grid_aspect_ratios.

Een ander basismodel gebruiken

Als u een ander basismodel wilt gebruiken, moet u een andere modelconfiguratie kiezen in de get_configuration() methode van run_fast_rcnn.py. Er worden direct twee modellen ondersteund:

    # 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

Als u het VGG16-model wilt downloaden, gebruikt u het downloadscript in <cntkroot>/PretrainedModels:

    python download_model.py VGG16_ImageNet_Caffe

Als u een ander basismodel wilt gebruiken, moet u bijvoorbeeld het configuratiebestand utils/configs/VGG16_config.py kopiëren en wijzigen op basis van uw basismodel:

# 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

Als u de knooppuntnamen van uw basismodel wilt onderzoeken, kunt u de plot() methode van cntk.logging.graph. ResNet-modellen worden momenteel niet ondersteund, omdat roipooling in CNTK nog geen ondersteuning biedt voor gemiddelde pooling van rois.

Details van algoritme

Snel R-CNN

R-CNN's voor objectdetectie werden voor het eerst gepresenteerd in 2014 door Ross Girshick et al., en werden aangetoond dat ze beter presteren dan de vorige state-of-the-art benaderingen op een van de belangrijkste uitdagingen voor objectherkenning op het gebied: Pascal VOC. Sindsdien werden twee follow-updocumenten gepubliceerd die aanzienlijke snelheidsverbeteringen bevatten: Fast R-CNN en Snellere R-CNN.

Het basisidee van R-CNN is het nemen van een diep neuraal netwerk dat oorspronkelijk is getraind voor afbeeldingsclassificatie met behulp van miljoenen geannoteerde afbeeldingen en deze te wijzigen voor objectdetectie. Het basisidee uit het eerste R-CNN-document wordt geïllustreerd in de onderstaande afbeelding (afkomstig van het document): (1) Gegeven een invoerafbeelding( 2) in een eerste stap worden er voorstellen voor een groot aantal regio's gegenereerd. (3) Deze regiovoorstellen, of regio-of-belangen (URI's), worden vervolgens onafhankelijk verzonden via het netwerk dat een vector levert van bijvoorbeeld 4096 drijvendekommawaarden voor elk RENDEMENT. Ten slotte wordt (4) een classificatie geleerd die de 4096 float ROI vertegenwoordigt als invoer en uitvoer van een label en betrouwbaarheid voor elke ROI.

Afbeelding

Hoewel deze aanpak goed werkt in termen van nauwkeurigheid, is het zeer kostbaar om te berekenen omdat het neurale netwerk moet worden geëvalueerd voor elke ROI. Fast R-CNN pakt dit nadeel aan door slechts het grootste deel van het netwerk te evalueren (om specifiek te zijn: de convolutielagen) één keer per afbeelding. Volgens de auteurs leidt dit tot een versnelling van 213 keer tijdens het testen en een snelheid van 9x tijdens het trainen zonder verlies van nauwkeurigheid. Dit wordt bereikt met behulp van een poollaag voor roi die het rendement op de convolutionele functietoewijzing projecteert en maximale pooling uitvoert om de gewenste uitvoergrootte te genereren die de volgende laag verwacht. In het AlexNet-voorbeeld dat in deze zelfstudie wordt gebruikt, wordt de poollaag roi geplaatst tussen de laatste convolutionele laag en de eerste volledig verbonden laag. In de CNTK Python API-code die hieronder wordt weergegeven, wordt dit gerealiseerd door het klonen van twee delen van het netwerk, de conv_layers en de fc_layers. De invoerafbeelding wordt vervolgens eerst genormaliseerd, gepusht door de conv_layersroipooling laag en de fc_layers voorspellings- en regressiekoppen, die respectievelijk het klasselabel en de regressiecoëfficiënten per kandidaat-ROI voorspellen.

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

De oorspronkelijke Caffe-implementatie die in de R-CNN-documenten wordt gebruikt, vindt u op GitHub: RCNN, Fast R-CNN en Snellere R-CNN.

SVM versus NN-training

Patrick Buehler biedt instructies over het trainen van een SVM op de CNTK Fast R-CNN-uitvoer (met behulp van de 4096-functies van de laatste volledig verbonden laag) en een discussie over voor- en nadelen hier.

Selectief zoeken is een methode voor het vinden van een grote set mogelijke objectlocaties in een afbeelding, onafhankelijk van de klasse van het werkelijke object. Het werkt door afbeeldings pixels te clusteren in segmenten en vervolgens hiërarchische clustering uit te voeren om segmenten van hetzelfde object te combineren in objectvoorstellen.

afbeelding van afbeelding

Om de gedetecteerde URI's van Selectief zoeken aan te vullen, voegen we URI's toe die de afbeelding uniform bedekken op verschillende schalen en hoogte-breedteverhoudingen. In de afbeelding aan de linkerkant ziet u een voorbeelduitvoer van Selectief zoeken, waarbij elke mogelijke objectlocatie wordt gevisualiseerd door een groene rechthoek. URI's die te klein, te groot zijn, enzovoort, worden verwijderd (midden) en ten slotte WORDEN URI's toegevoegd die de afbeelding uniform bedekken (rechts). Deze rechthoeken worden vervolgens gebruikt als Regio's of Interest (URI's) in de R-CNN-pijplijn.

Het doel van het genereren van roi is om een kleine set ROIs te vinden die nochtans zo dicht mogelijk objecten in de afbeelding bedekken. Deze berekening moet voldoende snel zijn, terwijl tegelijkertijd objectlocaties op verschillende schalen en hoogte-breedteverhoudingen worden gevonden. Selectief zoeken bleek goed te presteren voor deze taak, met een goede nauwkeurigheid om de afwegingen te versnellen.

NMS (niet-maximale onderdrukking)

Objectdetectiemethoden voeren vaak meerdere detecties uit die hetzelfde object volledig of gedeeltelijk in een afbeelding behandelen. Deze URI's moeten worden samengevoegd om objecten te kunnen tellen en hun exacte locaties in de afbeelding te kunnen verkrijgen. Dit wordt traditioneel gedaan met behulp van een techniek genaamd Non Maximum Onderdrukking (NMS). De versie van NMS die we gebruiken (en die ook in de R-CNN-publicaties is gebruikt), voegt GEEN URI's samen, maar probeert in plaats daarvan te bepalen welke URI's het beste betrekking hebben op de werkelijke locaties van een object en verwijdert alle andere URI's. Dit wordt geïmplementeerd door iteratief het RENDEMENT te selecteren met het hoogste vertrouwen en alle andere ROIs te verwijderen die dit RENDEMENT aanzienlijk overlappen en worden geclassificeerd als van dezelfde klasse. De drempelwaarde voor de overlapping kan worden ingesteld in PARAMETERS.py (details).

Detectieresultaten vóór (links) en na (rechts) Niet-maximale onderdrukking:

afbeelding van afbeelding

mAP (gemiddelde gemiddelde precisie)

Zodra het model is getraind, kan de kwaliteit van het model worden gemeten met behulp van verschillende criteria, zoals precisie, relevante overeenkomsten, nauwkeurigheid, oppervlakte-onder-curve, enzovoort. Een veelvoorkomende metrische waarde die wordt gebruikt voor de pascal VOC-objectherkenningsvraag is het meten van de gemiddelde precisie (AP) voor elke klasse. De volgende beschrijving van Average Precision wordt genomen uit Everingham et. al. De gemiddelde gemiddelde precisie (mAP) wordt berekend door het gemiddelde van de APs van alle klassen te nemen.

Voor een bepaalde taak en klasse wordt de precisie-/relevante curve berekend op basis van de geclassificeerde uitvoer van een methode. Relevante overeenkomsten worden gedefinieerd als het aandeel van alle positieve voorbeelden die boven een bepaalde rang zijn gerangschikt. Precisie is het aandeel van alle voorbeelden boven die rang die afkomstig zijn van de positieve klasse. De AP geeft een overzicht van de vorm van de curve voor precisie/relevante overeenkomsten en wordt gedefinieerd als de gemiddelde precisie op een set van elf gelijk verdeelde relevante overeenkomstenniveaus [0,0,1, . . . ,1]:

Afbeelding

De precisie op elk relevante niveau r wordt geïnterpoleerd door de maximale precisie te nemen die wordt gemeten voor een methode waarvoor de overeenkomstige relevante overeenkomsten r overschrijden:

Afbeelding

waarbij p( ̃r) de gemeten precisie is bij relevante overeenkomsten ̃r. De bedoeling bij het interpoleren van de precisie-/relevante curve op deze manier is het verminderen van de impact van de "wiggles" in de precisie-/relevante curve, veroorzaakt door kleine variaties in de rangschikking van voorbeelden. Opgemerkt moet worden dat om een hoge score te verkrijgen, een methode precisie moet hebben op alle niveaus van relevante overeenkomsten– dit bestraft methoden die slechts een subset van voorbeelden met hoge precisie ophalen (bijvoorbeeld zijweergaven van auto's).

  • Last updated on