Delen via

Objectdetectie met Fast R-CNN

Inhoudsopgave

Samenvatting

afbeelding

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

Bovenstaande zijn voorbeelden van afbeeldingen en objectaantekeningen voor de kruideniersgegevensset (eerste afbeelding) en de Pascal VOC-gegevensset (tweede afbeelding) die in deze zelfstudie worden gebruikt.

Fast R-CNN is een algoritme voor objectdetectie dat in 2015 door Ross Girshick wordt voorgesteld. 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 diepgaande convolutionele netwerken. In vergelijking met het vorige werk maakt Fast R-CNN gebruik van een poolschema voor interessegroepen waarmee de berekeningen van de convolutionele lagen opnieuw kunnen worden gebruikt.

Extra materiaal: een gedetailleerde zelfstudie voor objectdetectie met CNTK Fast R-CNN met BrainScript (inclusief optionele SVM-training en het publiceren van het getrainde model als een Rest API) vindt u hier.

Instellen

Als u de code in dit voorbeeld wilt uitvoeren, hebt u een CNTK Python-omgeving nodig (zie hier voor hulp bij het instellen). Verder moet u enkele extra pakketten installeren. Ga naar de map FastRCNN en voer het volgende uit:

pip install -r requirements.txt

Bekend probleem: om scikit-learn te installeren, moet u mogelijk worden uitgevoerd conda install scikit-learn als u Anaconda Python gebruikt. U hebt verder Scikit-Image en OpenCV nodig om deze voorbeelden uit te voeren. Download de bijbehorende wielpakketten en installeer deze handmatig. Op Linux kunt conda install scikit-image opencvu . Voor Windows-gebruikers gaat u naar http://www.lfd.uci.edu/~gohlke/pythonlibs/en downloadt u:

  • Python 3.5
    • scikit_image-0.12.3-cp35-cp35m-win_amd64.whl
    • opencv_python-3.2.0-cp35-cp35m-win_amd64.whl

Nadat u de binaire wielbestanden hebt gedownload, installeert u deze met:

pip install your_download_folder/scikit_image-0.12.3-cp35-cp35m-win_amd64.whl

[! OPMERKING]: als u het bericht Geen module ziet met de naam verleden bij het uitvoeren van de scripts, voert u de opdracht uit pip install future.

In deze zelfstudiecode wordt ervan uitgegaan dat u 64-bits versie van Python 3.5 of 3.6 gebruikt, omdat de vereiste Fast R-CNN DLL-bestanden onder hulpprogramma's vooraf zijn samengesteld voor deze versies. Als uw taak het gebruik van een andere Python-versie vereist, moet u deze DLL-bestanden opnieuw compileren in de juiste omgeving (zie hieronder).

In de zelfstudie wordt verder ervan uitgegaan dat de map waarin cntk.exe zich bevindt zich in uw PATH-omgevingsvariabele bevindt. (Als u de map aan uw PAD wilt toevoegen, kunt u de volgende opdracht uitvoeren vanaf een opdrachtregel (ervan uitgaande dat de map waarin cntk.exe zich op uw computer bevindt, C:\src\CNTK\x64\Release): set PATH=C:\src\CNTK\x64\Release;%PATH%.)

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

De map Examples\Image\Detection\FastRCNN\BrainScript\fastRCNN\utils bevat vooraf gecompileerde binaire bestanden die vereist zijn voor het uitvoeren van Fast R-CNN. Deze versies die zich momenteel in de opslagplaats bevinden, zijn Python 3.5 en 3.6, alle 64-bits. Als u een andere versie nodig hebt, kunt u deze compileren met de volgende stappen:

  • git clone --recursive https://github.com/rbgirshick/fast-rcnn.git

  • cd $FRCN_ROOT/lib

  • make

    • In plaats van make dat u vanuit dezelfde map kunt uitvoeren python setup.py build_ext --inplace . In Windows moet u mogelijk opmerkingen maken over de extra compileerargumenten in lib/setup.py:
    ext_modules = [
  Extension(
      "utils.cython_bbox",
      ["utils/bbox.pyx"],
      #extra_compile_args=["-Wno-cpp", "-Wno-unused-function"],
  ),
  Extension(
      "utils.cython_nms",
      ["utils/nms.pyx"],
      #extra_compile_args=["-Wno-cpp", "-Wno-unused-function"],
  )
]

  • kopieer de gegenereerde cython_bbox en cython_nms binaire bestanden van $FRCN_ROOT/lib/utils naar $CNTK_ROOT/Examples/Image/Detection/fastRCNN/utils.

Voorbeeldgegevens en basislijnmodel

We gebruiken een vooraf getraind AlexNet-model als basis voor Fast-R-CNN-training. Het vooraf getrainde AlexNet is beschikbaar op https://www.cntk.ai/Models/AlexNet/AlexNet.model. Sla het model op op $CNTK_ROOT/PretrainedModels. Voer de gegevens uit om de gegevens te downloaden

python install_grocery.py

uit de Examples/Image/DataSets/Grocery map.

Het speelgoedvoorbeeld uitvoeren

In het speelgoedvoorbeeld trainen we een CNTK Fast R-CNN-model om boodschappen te detecteren in een koelkast. Alle vereiste scripts bevinden zich in $CNTK_ROOT/Examples/Image/Detection/FastRCNN/BrainScript.

Snelgids

Als u het speelgoedvoorbeeld wilt uitvoeren, moet u ervoor zorgen dat deze PARAMETERS.pydataset is ingesteld op "Grocery".

  • Voer deze opdracht A1_GenerateInputROIs.py uit om de invoer-URI's te genereren voor training en testen.
  • Voer uit A2_RunWithBSModel.py om te trainen en testen met behulp van cntk.exe en BrainScript.
  • Voer uit A3_ParseAndEvaluateOutput.py om de mAP (gemiddelde gemiddelde precisie) van het getrainde model te berekenen.

De uitvoer van script A3 moet het volgende bevatten:

Evaluating detections
AP for         avocado = 1.0000
AP for          orange = 1.0000
AP for          butter = 1.0000
AP for       champagne = 1.0000
AP for          eggBox = 0.7500
AP for          gerkin = 1.0000
AP for         joghurt = 1.0000
AP for         ketchup = 0.6667
AP for     orangeJuice = 1.0000
AP for           onion = 1.0000
AP for          pepper = 1.0000
AP for          tomato = 0.7600
AP for           water = 0.5000
AP for            milk = 1.0000
AP for         tabasco = 1.0000
AP for         mustard = 1.0000
Mean AP = 0.9173
DONE.

Als u de begrenzingsvakken en voorspelde labels wilt visualiseren, kunt u uitvoeren B3_VisualizeOutputROIs.py (klik op de afbeeldingen om te vergroten):

afbeelding van afbeelding

Stapdetails

A1: Het script A1_GenerateInputROIs.py genereert eerst ROI-kandidaten voor elke afbeelding met behulp van selectief zoeken. Vervolgens worden ze opgeslagen in een CNTK-tekstindeling als invoer voor cntk.exe. Daarnaast worden de vereiste CNTK-invoerbestanden voor de afbeeldingen en de grondwaarlabels gegenereerd. Het script genereert de volgende mappen en bestanden onder de FastRCNN map:

  • proc - hoofdmap voor gegenereerde inhoud.
    • grocery_2000 - bevat alle gegenereerde mappen en bestanden voor het grocery voorbeeld met behulp van 2000 URI's. Als u opnieuw uitvoert met een ander aantal URI's, wordt de mapnaam overeenkomstig gewijzigd.
      • rois - bevat de onbewerkte ROI-coördinaten voor elke afbeelding die is opgeslagen in tekstbestanden.
      • cntkFiles - bevat de opgemaakte CNTK-invoerbestanden voor afbeeldingen (train.txt en test.txt), ROI-coördinaten (xx.rois.txt) en ROI-labels (xx.roilabels.txt) voor train en test. (Details van opmaak vindt u hieronder.)

Alle parameters zijn opgenomen in PARAMETERS.py, bijvoorbeeld wijzigen cntk_nrRois = 2000 om het aantal URI's in te stellen dat wordt gebruikt voor training en testen. We beschrijven parameters in de sectie Parameters hieronder.

A2: Het script A2_RunWithBSModel.py voert cntk uit met behulp van cntk.exe en een BrainScript-configuratiebestand (configuratiedetails). Het getrainde model wordt opgeslagen in de map cntkFiles/Output van de bijbehorende proc submap. Het getrainde model wordt afzonderlijk getest op zowel de trainingsset als de testset. Tijdens het testen voor elke afbeelding en elke bijbehorende ROI wordt een label voorspeld en opgeslagen in de bestanden test.z en train.z in de cntkFiles map.

A3: De evaluatiestap parseert de CNTK-uitvoer en berekent de mAP die de voorspelde resultaten vergelijkt met de aantekeningen van de grondwaar. Niet-maximale onderdrukking wordt gebruikt om overlappende ROIs's samen te voegen. U kunt de drempelwaarde instellen voor niet-maximale onderdrukking in PARAMETERS.py (details).

Aanvullende scripts

Er zijn drie optionele scripts die u kunt uitvoeren om de gegevens te visualiseren en te analyseren:

  • B1_VisualizeInputROIs.py visualiseert de kandidaat-invoer-URI's.
  • B2_EvaluateInputROIs.py berekent het intrekken van de grondwaar-URI's met betrekking tot de kandidaat-URI's.
  • B3_VisualizeOutputROIs.py visualiseer de begrenzingsvakken en voorspelde labels.

Pascal VOC uitvoeren

De Pascal VOC-gegevens (PASCAL Visual Object Classes) zijn een bekende set gestandaardiseerde afbeeldingen voor objectklasseherkenning. Voor het trainen of testen van CNTK Fast R-CNN op de Pascal VOC-gegevens is een GPU met ten minste 4 GB RAM vereist. U kunt ook uitvoeren met behulp van de CPU, wat echter enige tijd kost.

De Pascal VOC-gegevens ophalen

U hebt de gegevens van 2007 (trainval en test) en 2012 (trainval) nodig, evenals de vooraf ingevulde ROIs's die in het oorspronkelijke papier worden gebruikt. U moet de mapstructuur volgen die hieronder wordt beschreven. In de scripts wordt ervan uitgegaan dat de Pascal-gegevens zich in $CNTK_ROOT/Examples/Image/DataSets/Pascalbevinden. Als u een andere map gebruikt, stelt pascalDataDir u dienovereenkomstig in PARAMETERS.py .

De VOCdevkit2007 map moet er als volgt uitzien (vergelijkbaar voor 2012):

VOCdevkit2007/VOC2007
VOCdevkit2007/VOC2007/Annotations
VOCdevkit2007/VOC2007/ImageSets
VOCdevkit2007/VOC2007/JPEGImages

CNTK uitvoeren op Pascal VOC

Als u wilt uitvoeren op de Pascal VOC-gegevens, moet u ervoor zorgen dat in PARAMETERS.pydataset is ingesteld op "pascal".

  • Voer deze opdracht A1_GenerateInputROIs.py uit om de cntk opgemaakte invoerbestanden te genereren voor training en testen op basis van de gedownloade ROI-gegevens.
  • Voer deze opdracht A2_RunWithBSModel.py uit om een Fast R-CNN-model en rekentestresultaten te trainen.
  • Voer deze opdracht A3_ParseAndEvaluateOutput.py uit om de mAP (gemiddelde precisie) van het getrainde model te berekenen.
    • Houd er rekening mee dat dit werk wordt uitgevoerd en dat de resultaten voorlopig zijn, omdat we nieuwe basislijnmodellen trainen.
    • Zorg ervoor dat u de nieuwste versie van cntk-master hebt voor de bestanden fastRCNN/pascal_voc.py en fastRCNN/voc_eval.py om coderingsfouten te voorkomen.

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

Voordat u CNTK Fast R-CNN uitvoert met behulp van scripts A1-A3, moet u uw gegevensset toevoegen aan PARAMETERS.py:

  • Instellen dataset = "CustomDataset"
  • Voeg de parameters voor uw gegevensset toe onder de Python-klasse CustomDataset. U kunt beginnen met het kopiëren van de parameters van GroceryParameters
    • Pas de klassen aan zodat deze overeenkomen met de objectcategorieën. In het bovenstaande voorbeeld ziet dit er ongeveer als volgt self.classes = ('__background__', 'dog', 'cat', 'octopus')uit.
    • Instellen self.imgDir = <your_image_folder>.
    • U kunt desgewenst meer parameters aanpassen, bijvoorbeeld voor het genereren en verwijderen van het rendement (zie de sectie Parameters ).

Klaar om te trainen op uw eigen gegevens! (Gebruik dezelfde stappen als voor het speelgoedvoorbeeld.)

Technische details

Parameters

De belangrijkste parameters zijn PARAMETERS.py

  • dataset - welke gegevensset moet worden gebruikt
  • cntk_nrRois - hoeveel URI's moeten worden gebruikt voor training en testen
  • nmsThreshold - Drempelwaarde voor niet-maximale onderdrukking (in bereik [0,1]). Hoe lager hoe meer URI's worden gecombineerd. Het wordt gebruikt voor zowel evaluatie als visualisatie.

Alle parameters voor het genereren van roi's, zoals minimale en maximale breedte en hoogte, worden beschreven in PARAMETERS.py de Python-klasse Parameters. Ze zijn allemaal ingesteld op een standaardwaarde die redelijk is. U kunt ze overschrijven in de # project-specific parameters sectie die overeenkomt met de gegevensset die u gebruikt.

CNTK-configuratie

Het CNTK BrainScript-configuratiebestand dat wordt gebruikt om Fast R-CNN te trainen en te testen, is fastrcnn.cntk. Het deel dat het netwerk maakt, is de BrainScriptNetworkBuilder sectie in de Train opdracht:

BrainScriptNetworkBuilder = {
    network     = BS.Network.Load ("../../../../../../../PretrainedModels/AlexNet.model")
    convLayers  = BS.Network.CloneFunction(network.features, network.conv5_y, parameters = "constant")
    fcLayers    = BS.Network.CloneFunction(network.pool3, network.h2_d)

    model (features, rois) = {
        featNorm = features - 114
        convOut  = convLayers (featNorm)
        roiOut   = ROIPooling (convOut, rois, (6:6))
        fcOut    = fcLayers (roiOut)
        W        = ParameterTensor{($NumLabels$:4096), init="glorotUniform"}
        b        = ParameterTensor{$NumLabels$, init = 'zero'}
        z        = W * fcOut + b
    }.z

    imageShape = $ImageH$:$ImageW$:$ImageC$         # 1000:1000:3
    labelShape = $NumLabels$:$NumTrainROIs$         # 21:64
    ROIShape   = 4:$NumTrainROIs$                   # 4:64

    features = Input {imageShape}
    roiLabels = Input {labelShape}
    rois = Input {ROIShape}

    z = model (features, rois)

    ce = CrossEntropyWithSoftmax(roiLabels, z, axis = 1)
    errs = ClassificationError(roiLabels, z, axis = 1)

    featureNodes    = (features:rois)
    labelNodes      = (roiLabels)
    criterionNodes  = (ce)
    evaluationNodes = (errs)
    outputNodes     = (z)
}

In de eerste regel wordt het vooraf getrainde AlexNet geladen als basismodel. De volgende twee delen van het netwerk worden gekloond: convLayers bevat de convolutionele lagen met constante gewichten, d.w. ze worden niet verder getraind. fcLayers bevat de volledig verbonden lagen met de vooraf getrainde gewichten, die verder worden getraind. De knooppuntnamen network.features, enzovoort, network.conv5_y kunnen worden afgeleid van het bekijken van de logboekuitvoer van de cntk.exe-aanroep (opgenomen in de logboekuitvoer van het A2_RunWithBSModel.py script).

De modeldefinitie(model (features, rois) = ...) normaliseert eerst de functies door 114 af te trekken voor elk kanaal en elke pixel. Vervolgens worden de genormaliseerde functies door de gevolgd door de convLayersROIPooling en ten slotte de fcLayers. De uitvoershape (breedte:hoogte) van de poollaag ROI is ingesteld op (6:6) omdat dit de grootte van de shape is die het vooraf getrainde fcLayers AlexNet-model verwacht. De uitvoer van de fcLayers uitvoer wordt ingevoerd in een dichte laag die één waarde per label (NumLabels) voorspelt voor elk RENDEMENT.

De volgende zes regels definiëren de invoer:

  • een afbeelding van grootte 1000 x 1000 x 3 ($ImageH$:$ImageW$:$ImageC$),
  • grondwaarlabels voor elk RENDEMENT ($NumLabels$:$NumTrainROIs$)
  • en vier coördinaten per ROI (4:$NumTrainROIs$) die overeenkomen met (x, y, w, h), allemaal relatief ten opzichte van de volledige breedte en hoogte van de afbeelding.

z = model (features, rois) voert de invoerafbeeldingen en URI's in het gedefinieerde netwerkmodel en wijst de uitvoer toe aan z. Zowel het criterium (CrossEntropyWithSoftmax) als de fout (ClassificationError) worden opgegeven om rekening te houden met axis = 1 de voorspellingsfout per ROI.

De sectie Lezer van de CNTK-configuratie wordt hieronder vermeld. Er worden drie deserializers gebruikt:

  • ImageDeserializer om de afbeeldingsgegevens te lezen. Hiermee worden de namen van train.txtafbeeldingsbestanden opgehaald, wordt de afbeelding geschaald naar de gewenste breedte en hoogte, terwijl de hoogte-breedteverhouding behouden blijft (opvulling lege gebieden met 114) en de tensor transponeert om de juiste invoervorm te hebben.
  • Eén CNTKTextFormatDeserializer om de ROI-coördinaten van train.rois.txtte lezen.
  • Een seconde CNTKTextFormatDeserializer om de ROI-labels van train.roislabels.txtte lezen.

De invoerbestandsindelingen worden beschreven in de volgende sectie.

reader = {
    randomize = false
    verbosity = 2
    deserializers = ({
        type = "ImageDeserializer" ; module = "ImageReader"
        file = train.txt
        input = {
            features = { transforms = (
                { type = "Scale" ; width = $ImageW$ ; height = $ImageW$ ; channels = $ImageC$ ; scaleMode = "pad" ; padValue = 114 }:
                { type = "Transpose" }
            )}
            ignored = {labelDim = 1000}
        }
    }:{
        type = "CNTKTextFormatDeserializer" ; module = "CNTKTextFormatReader"
        file = train.rois.txt
        input = { rois = { dim = $TrainROIDim$ ; format = "dense" } }
    }:{
        type = "CNTKTextFormatDeserializer" ; module = "CNTKTextFormatReader"
        file = train.roilabels.txt
        input = { roiLabels = { dim = $TrainROILabelDim$ ; format = "dense" } }
    })
}

CNTK-invoerbestandsindeling

Er zijn drie invoerbestanden voor CNTK Fast R-CNN die overeenkomen met de drie deserializers die hierboven worden beschreven:

  1. train.txt bevat in elke regel eerst een volgnummer, vervolgens een bestandsnamen van afbeeldingen en ten slotte een 0 (die momenteel nog steeds nodig is om verouderde redenen van ImageReader).
0 image_01.jpg 0
1 image_02.jpg 0
...
  1. train.rois.txt (CNTK-tekstindeling) bevat in elke regel eerst een volgnummer en vervolgens de |rois id gevolgd door een reeks getallen. Dit zijn groepen van vier getallen die overeenkomen met (x, y, w, h) van een ROI, allemaal relatief ten opzichte van de volledige breedte en hoogte van de afbeelding. Er zijn in totaal 4 * aantal rois-getallen per regel.
0 |rois 0.2185 0.0 0.165 0.29 ...
  1. train.roilabels.txt (CNTK-tekstindeling) bevat in elke regel eerst een volgnummer en vervolgens de |roiLabels id gevolgd door een reeks getallen. Dit zijn groepen met getallen van het aantal labels (nul of één) per ROI die de grondwaarklasse coderen in een one-hot weergave. Er is een totaal aantal labels * aantal-of-rois-getallen per regel.
0 |roiLabels 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0  ...

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 (zie BrainScript-code).

De oorspronkelijke Caffe-implementatie die in de R-CNN-documenten wordt gebruikt, vindt u op GitHub: RCNN, Fast R-CNN en Snellere R-CNN. In deze zelfstudie wordt een deel van de code uit deze opslagplaatsen gebruikt, met name (maar niet uitsluitend) voor SVM-training en modelevaluatie.

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 eerste afbeelding 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 (tweede afbeelding) en ten slotte WORDEN URI's toegevoegd (derde afbeelding). 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 (eerste afbeelding) en na (tweede afbeelding) 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