Freigeben über

Objekterkennung mithilfe von Fast R-CNN

  • Artikel

Inhaltsverzeichnis

Zusammenfassung

Bild

In diesem Lernprogramm wird beschrieben, wie Sie CNTK Fast R-CNN mit BrainScript und cntk.exe verwenden. SchnelleS R-CNN mit der CNTK Python-API wird hier beschrieben.

Die obigen Beispiele sind Beispiele für Bilder und Objektanmerkungen für den Lebensmitteldatensatz (erstes Bild) und das in diesem Lernprogramm verwendete Pascal VOC-Dataset (zweite Abbildung).

Fast R-CNN ist ein Objekterkennungsalgorithmus, der 2015 von Ross Girshick vorgeschlagen wird. Das Papier wird an ICCV 2015 angenommen und archiviert unter https://arxiv.org/abs/1504.08083. Fast R-CNN baut auf früheren Arbeiten auf, um Objektvorschläge mithilfe von tiefen konvolutionalen Netzwerken effizient zu klassifizieren. Im Vergleich zu früheren Arbeiten verwendet Fast R-CNN eine Region von Interessenpooling-Schema , mit der die Berechnungen aus den konvolutionalen Ebenen wiederverwendet werden können.

Zusätzliches Material: Ein detailliertes Lernprogramm zur Objekterkennung mit CNTK Fast R-CNN mit BrainScript (einschließlich optionaler SVM-Schulung und Veröffentlichung des trainierten Modells als Rest-API) finden Sie hier.

Einrichten

Um den Code in diesem Beispiel auszuführen, benötigen Sie eine CNTK Python-Umgebung (siehe hier , um Hilfe zur Einrichtung zu erhalten). Darüber hinaus müssen Sie einige zusätzliche Pakete installieren. Wechseln Sie zum FastRCNN-Ordner, und führen Sie Folgendes aus:

pip install -r requirements.txt

Bekanntes Problem: Um scikit-learn zu installieren, müssen Sie möglicherweise ausführen conda install scikit-learn , wenn Sie Anaconda Python verwenden. Sie benötigen weitere Scikit-Image und OpenCV, um diese Beispiele auszuführen. Laden Sie die entsprechenden Radpakete herunter, und installieren Sie sie manuell. Unter Linux können conda install scikit-image opencvSie . Für Windows-Benutzer besuchen http://www.lfd.uci.edu/~gohlke/pythonlibs/Sie und laden Sie folgendes herunter:

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

Nachdem Sie die entsprechenden Rad-Binärdateien heruntergeladen haben, installieren Sie sie mit:

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

[! HINWEIS]: Wenn beim Ausführen der Skripts die Meldung "Kein Modul" angezeigt wird, führen Sie dies aus pip install future.

In diesem Lernprogrammcode wird davon ausgegangen, dass Sie 64Bit-Version von Python 3.5 oder 3.6 verwenden, da die erforderlichen Fast R-CNN-DLL-Dateien unter "utils " für diese Versionen vorinstalliert sind. Wenn Ihre Aufgabe die Verwendung einer anderen Python-Version erfordert, kompilieren Sie diese DLL-Dateien selbst in der richtigen Umgebung (siehe unten).

Im Lernprogramm wird weiter davon ausgegangen, dass sich der Ordner, in dem sich cntk.exe befindet, in Ihrer PATH-Umgebungsvariable befindet. (Um den Ordner zu Ihrem PATH hinzuzufügen, können Sie den folgenden Befehl über eine Befehlszeile ausführen (vorausgesetzt, der Ordner, in dem sich cntk.exe auf Ihrem Computer befindet, ist C:\src\CNTK\x64\Release): set PATH=C:\src\CNTK\x64\Release;%PATH%.)

Vorkompilierte Binärdateien für begrenzungsfeldregression und nicht maximale Unterdrückung

Der Ordner Examples\Image\Detection\FastRCNN\BrainScript\fastRCNN\utils enthält vorab kompilierte Binärdateien, die für die Ausführung von Fast R-CNN erforderlich sind. Diese Versionen, die derzeit im Repository enthalten sind, sind Python 3.5 und 3.6, alle 64 Bit. Wenn Sie eine andere Version benötigen, können Sie sie in folgenden Schritten kompilieren:

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

  • cd $FRCN_ROOT/lib

  • make

    • Statt aus make demselben Ordner auszuführen python setup.py build_ext --inplace . Unter Windows müssen Sie möglicherweise die zusätzlichen Kompilierungsargumente in lib/setup.py kommentieren:
    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"],
  )
]

  • Kopieren Sie die generierten cython_bbox und cython_nms binärdateien von $FRCN_ROOT/lib/utils auf $CNTK_ROOT/Examples/Image/Detection/fastRCNN/utils.

Beispieldaten und Basismodell

Wir verwenden ein vortrainiertes AlexNet-Modell als Basis für fast-R-CNN-Schulungen. Die vortrainierte AlexNet ist unter https://www.cntk.ai/Models/AlexNet/AlexNet.model. Bitte speichern Sie das Modell unter $CNTK_ROOT/PretrainedModels. Führen Sie die Ausführung aus, um die Daten herunterzuladen.

python install_grocery.py

aus dem Examples/Image/DataSets/Grocery Ordner.

Ausführen des Toy-Beispiels

Im Toy-Beispiel trainieren wir ein CNTK Fast R-CNN-Modell, um Lebensmittel in einem Kühlschrank zu erkennen. Alle erforderlichen Skripts befinden sich in $CNTK_ROOT/Examples/Image/Detection/FastRCNN/BrainScript.

Kurzanleitung

Um das Toy-Beispiel auszuführen, stellen Sie sicher, dass in PARAMETERS.pydataset"Grocery"

  • Führen Sie die Ausführung A1_GenerateInputROIs.py aus, um die Eingabe-ROIs für Schulungen und Tests zu generieren.
  • Führen Sie die Ausführung A2_RunWithBSModel.py aus, um cntk.exe und BrainScript zu trainieren und zu testen.
  • Führen Sie die Ausführung A3_ParseAndEvaluateOutput.py aus, um das mAP (mitteldurchschnittliche Genauigkeit) des trainierten Modells zu berechnen.

Die Ausgabe von Skript A3 sollte Folgendes enthalten:

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.

Zum Visualisieren der umgebenden Felder und vorhergesagter Bezeichnungen können Sie ausführen B3_VisualizeOutputROIs.py (klicken Sie auf die Bilder, um zu vergrößern):

Bildbildbildbild

Schrittdetails

A1: Das Skript A1_GenerateInputROIs.py generiert zuerst ROI-Kandidaten für jedes Bild mithilfe der selektiven Suche. Anschließend wird sie in einem CNTK-Textformat als Eingabe gespeichert cntk.exe. Darüber hinaus werden die erforderlichen CNTK-Eingabedateien für die Bilder und die Bezeichnungen der Grund-Wahrheit generiert. Das Skript generiert die folgenden Ordner und Dateien unter dem FastRCNN Ordner:

  • proc - Stammordner für generierte Inhalte.
    • grocery_2000 - enthält alle generierten Ordner und Dateien für das grocery Beispiel mit 2000 ROIs. Wenn Sie erneut mit einer anderen Anzahl von ROIs ausgeführt werden, ändert sich der Ordnername entsprechend.
      • rois - enthält die unformatierten ROI-Koordinaten für jedes Bild, das in Textdateien gespeichert ist.
      • cntkFiles- enthält die formatierten CNTK-Eingabedateien für Bilder (train.txt und ), ROI-Koordinaten () und test.txtROI-Bezeichnungen (xx.rois.txtxx.roilabels.txt) für train und test. (Formatdetails werden unten angegeben.)

Alle Parameter sind in PARAMETERS.pyenthalten, z. B. ändern cntk_nrRois = 2000 , um die Anzahl der für Schulungen und Tests verwendeten ROIs festzulegen. Wir beschreiben Parameter im Abschnitt Parameter unten.

A2: Das Skript A2_RunWithBSModel.py führt Cntk mit cntk.exe und einer BrainScript-Konfigurationsdatei (Konfigurationsdetails) aus. Das trainierte Modell wird im Ordner cntkFiles/Output des entsprechenden proc Unterordners gespeichert. Das trainierte Modell wird sowohl für den Schulungssatz als auch für den Testsatz separat getestet. Während der Tests für jedes Bild und jeden entsprechenden ROI wird eine Bezeichnung vorhergesagt und in den Dateien test.z und train.z im cntkFiles Ordner gespeichert.

A3: Der Auswertungsschritt analysiert die CNTK-Ausgabe und berechnet das MAP , das die vorhergesagten Ergebnisse mit den Anmerkungen zur Boden-Wahrheit vergleicht. Nicht maximale Unterdrückung wird verwendet, um überlappende ROIs zusammenzuführen. Sie können den Schwellenwert für die nicht maximale Unterdrückung in PARAMETERS.py (Details) festlegen.

Weitere Skripts

Es gibt drei optionale Skripts, die Sie ausführen können, um die Daten zu visualisieren und zu analysieren:

  • B1_VisualizeInputROIs.py visualisiert die Kandidateneingabe-ROIs.
  • B2_EvaluateInputROIs.py berechnet den Rückruf der Boden-Wahrheits-ROIs im Hinblick auf die Kandidaten-ROIs.
  • B3_VisualizeOutputROIs.py Visualisieren Sie die Begrenzungsfelder und vorhergesagte Beschriftungen.

Pascal VOC ausführen

Die Pascal VOC-Daten (Pascal Visual Object Classes) sind ein bekannter Satz standardisierter Bilder für die Objektklassenerkennung. Schulung oder Testen von CNTK Fast R-CNN auf den Pascal VOC-Daten erfordert eine GPU mit mindestens 4 GB RAM. Alternativ können Sie die CPU verwenden, die jedoch einige Zeit in Anspruch nimmt.

Abrufen der Pascal VOC-Daten

Sie benötigen die Daten 2007 (trainval and test) und 2012 (trainval) sowie die im Originalpapier verwendeten vorkompilierten ROIs. Sie müssen der unten beschriebenen Ordnerstruktur folgen. Die Skripts gehen davon aus, dass sich die Pascal-Daten befinden $CNTK_ROOT/Examples/Image/DataSets/Pascal. Wenn Sie einen anderen Ordner verwenden, legen Sie bitte entsprechend fest pascalDataDirPARAMETERS.py .

Der VOCdevkit2007 Ordner sollte wie folgt aussehen (ähnlich für 2012):

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

Ausführen von CNTK auf Pascal VOC

Um auf den Pascal VOC-Daten auszuführen, stellen Sie sicher, dass in PARAMETERS.pydataset festgelegt ist "pascal".

  • Führen Sie A1_GenerateInputROIs.py aus, um die formatierten CNTK-Eingabedateien für Schulungen und Tests aus den heruntergeladenen ROI-Daten zu generieren.
  • Führen Sie A2_RunWithBSModel.py aus, um ein Schnelles R-CNN-Modell zu trainieren und Testergebnisse zu berechnen.
  • Führen Sie A3_ParseAndEvaluateOutput.py aus, um die mAP (durchschnittliche Genauigkeit) des trainierten Modells zu berechnen.
    • Bitte beachten Sie, dass dies in Bearbeitung ist, und die Ergebnisse sind vorläufige, da wir neue Basismodelle trainieren.
    • Stellen Sie sicher, dass sie über die neueste Version von CNTK master für die Dateien fastRCNN/pascal_voc.py und fastRCNN/voc_eval.py verfügen, um Codierungsfehler zu vermeiden.

Trainieren Sie ihre eigenen Daten

Vorbereiten eines benutzerdefinierten Datasets

Option #1: Visual Object Tagging Tool (Empfohlen)

Das Visual Object Tagging Tool (VOTT) ist ein plattformübergreifendes Anmerkungstool für das Markieren von Video- und Bildressourcen.

Vott Screenshot

VOTT bietet die folgenden Features:

  • Computergestütztes Tagging und Nachverfolgen von Objekten in Videos mithilfe des Camshift-Tracking-Algorithmus.
  • Exportieren von Tags und Ressourcen in das CNTK Fast-RCNN-Format für die Schulung eines Objekterkennungsmodells.
  • Ausführen und Überprüfen eines trainierten CNTK-Objekterkennungsmodells auf neuen Videos, um stärkere Modelle zu generieren.

So werden Sie mit VOTT annotiert:

  1. Laden Sie die neueste Version herunter
  2. Folgen Sie dem Readme , um einen Taggingauftrag auszuführen.
  3. Nach dem Markieren von Exporttags in das Datasetverzeichnis

Option #2: Verwenden von Anmerkungenskripts

Um ein CNTK Fast R-CNN-Modell auf Ihrem eigenen Datensatz zu trainieren, bieten wir zwei Skripts zum Annotieren von rechteckigen Regionen in Bildern und Zuweisen von Bezeichnungen zu diesen Regionen. Die Skripts speichern die Anmerkungen im richtigen Format wie erforderlich durch den ersten Schritt beim Ausführen von Fast R-CNN (A1_GenerateInputROIs.py). Speichern Sie zuerst Ihre Bilder in der folgenden Ordnerstruktur

  • <your_image_folder>/negative - Bilder, die für Schulungen verwendet werden, die keine Objekte enthalten
  • <your_image_folder>/positive - Bilder, die für Schulungen verwendet werden, die Objekte enthalten
  • <your_image_folder>/testImages - Bilder, die für Tests verwendet werden, die Objekte enthalten

Für die negativen Bilder müssen Sie keine Anmerkungen erstellen. Für die anderen beiden Ordner werden die bereitgestellten Skripts verwendet:

  • Führen Sie aus C1_DrawBboxesOnImages.py , um begrenzungsgebundene Felder auf den Bildern zu zeichnen.
    • Im Skriptsatz imgDir = <your_image_folder> (/positive oder /testImages) vor dem Ausführen.
    • Fügen Sie Anmerkungen mithilfe des Mauszeigers hinzu. Sobald alle Objekte in einem Bild annotiert sind, schreibt das Drücken der TASTE 'n' die Datei .bboxes.txt und geht dann auf das nächste Bild fort, "u" rückgängig (d. h. entfernt) das letzte Rechteck, und 'q' beendet das Anmerkungstool.
  • Führen Sie C2_AssignLabelsToBboxes.py aus, um Beschriftungen den Begrenzungsfeldern zuzuweisen.
    • Im Skriptsatz imgDir = <your_image_folder> (/positive oder /testImages) vor dem Ausführen...
    • ... und passen Sie die Klassen im Skript an, um Ihre Objektkategorien zu widerspiegeln, z classes = ("dog", "cat", "octopus"). B. .
    • Das Skript lädt diese manuell annotierten Rechtecks für jedes Bild, zeigt sie eins nacheinander an, und fordert den Benutzer auf, die Objektklasse bereitzustellen, indem sie links neben dem Fenster auf die entsprechende Schaltfläche klicken. Grund-Wahrheitsanmerkungen, die entweder als "nicht entschieden" oder "ausgeschlossen" gekennzeichnet sind, sind vollständig aus der weiteren Verarbeitung ausgeschlossen.

Trainieren auf benutzerdefiniertem Dataset

Bevor Sie CNTK Fast R-CNN mit Skripts A1-A3 ausführen, müssen Sie Ihren Datensatz PARAMETERS.pyhinzufügen:

  • Festgelegt dataset = "CustomDataset"
  • Fügen Sie die Parameter für Ihren Datensatz unter der Python-Klasse CustomDatasethinzu. Sie können beginnen, indem Sie die Parameter aus kopieren. GroceryParameters
    • Passen Sie die Klassen an, um Ihre Objektkategorien widerzuspiegeln. Im folgenden Beispiel würde dies aussehen self.classes = ('__background__', 'dog', 'cat', 'octopus').
    • Legen Sie self.imgDir = <your_image_folder> fest.
    • Optional können Sie weitere Parameter anpassen, z. B. für die ROI-Generation und die Schnitte (siehe Abschnitt "Parameter ").

Bereit zum Trainieren auf eigenen Daten! (Verwenden Sie die gleichen Schritte wie für das Toy-Beispiel.)

Technische Details

Parameter

Die wichtigsten Parameter PARAMETERS.py in sind

  • dataset - welche Datensätze verwendet werden sollen
  • cntk_nrRois - wie viele ROIs für Schulungen und Tests verwendet werden sollen
  • nmsThreshold - Schwellenwert für nicht maximale Unterdrückung (im Bereich [0,1]). Je niedriger die mehr ROIs kombiniert werden. Sie wird sowohl für die Auswertung als auch für die Visualisierung verwendet.

Alle Parameter für die ROI-Generation, z. B. minimale und maximale Breite und Höhe usw., werden unter PARAMETERS.py der Python-Klasse Parametersbeschrieben. Sie sind alle auf einen Standardwert festgelegt, der sinnvoll ist. Sie können sie im Abschnitt überschreiben, der # project-specific parameters dem verwendeten Datensatz entspricht.

CNTK-Konfiguration

Die CNTK BrainScript-Konfigurationsdatei, die zum Trainieren und Testen von Fast R-CNN verwendet wird, ist fastrcnn.cntk. Der Teil, der Train das Netzwerk erstellt, ist der BrainScriptNetworkBuilder Abschnitt im Befehl:

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 der ersten Zeile wird alexNet als Basismodell geladen. Als nächstes zwei Teile des Netzwerks werden geklont: convLayers enthält die konvolutionalen Schichten mit konstanten Gewichten, d. h. sie werden nicht weiter trainiert. fcLayers enthält die vollständig verbundenen Schichten mit den vortrainierten Gewichten, die weiter trainiert werden. Die Knotennamen network.featuresusw network.conv5_y . können von der Protokollausgabe des cntk.exe-Aufrufs (in der Protokollausgabe des A2_RunWithBSModel.py Skripts enthalten) abgeleitet werden.

Die Modelldefinition(model (features, rois) = ...) normalisiert zuerst die Features, indem sie 114 für jeden Kanal und Pixel subtrahieren. Anschließend werden die normalisierten Features durch convLayers die gefolgt von der ROIPooling und schließlich durch fcLayersdie . Die Ausgabeform (Breite:Höhe) der ROI-Pooling-Ebene wird festgelegt (6:6) , da dies die Form-nd-Größe ist, die vor dem AlexNet-Modell erwartet fcLayers wird. Die Ausgabe der fcLayers Datei wird in eine dichte Ebene eingespeist, die einen Wert pro Bezeichnung (NumLabels) für jeden ROI vorhersagt.

Die folgenden sechs Zeilen definieren die Eingabe:

  • Ein Bild von Größe 1000 x 1000 x 3 ($ImageH$:$ImageW$:$ImageC$),
  • Grund-Wahrheitsbezeichnungen für jeden ROI ($NumLabels$:$NumTrainROIs$)
  • und vier Koordinaten pro ROI (4:$NumTrainROIs$) entsprechend (x, y, w, h), alle relativ in Bezug auf die vollständige Breite und Höhe des Bilds.

z = model (features, rois) leitet die Eingabebilder und ROIs in das definierte Netzwerkmodell ein und weist die Ausgabe zu z. Sowohl das Kriterium () als auch der Fehler (CrossEntropyWithSoftmaxClassificationError) werden angegebenaxis = 1, um den Prognosefehler pro ROI zu berücksichtigen.

Der Abschnitt "Reader" der CNTK-Konfiguration wird unten aufgeführt. Es verwendet drei Deserializer:

  • ImageDeserializer um die Bilddaten zu lesen. Es erfasst die Bilddateinamen von train.txt, skaliert das Bild auf die gewünschte Breite und Höhe, während das Seitenverhältnis beibehalten wird (leere Bereiche 114mit ) und transponiert den Tensor, um die richtige Eingabeform zu haben.
  • Eine CNTKTextFormatDeserializer , um die ROI-Koordinaten aus train.rois.txtzu lesen.
  • Eine Sekunde CNTKTextFormatDeserializer , um die ROI-Bezeichnungen aus train.roislabels.txtzu lesen.

Die Eingabedateiformate werden im nächsten Abschnitt beschrieben.

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-Eingabedateiformat

Es gibt drei Eingabedateien für CNTK Fast R-CNN, die den drei oben beschriebenen Deserializern entsprechen:

  1. train.txt enthält in jeder Zeile zuerst eine Sequenznummer, dann ein Bilddateiname und schließlich eine 0 (die derzeit noch aus Legacygründen des ImageReader benötigt wird).
0 image_01.jpg 0
1 image_02.jpg 0
...
  1. train.rois.txt (CNTK-Textformat) enthält in jeder Zeile zuerst eine Sequenznummer, dann den |rois Bezeichner, gefolgt von einer Sequenz von Zahlen. Dies sind Gruppen von vier Zahlen, die (x, y, w, h) eines ROI entsprechen, alle relativ in Bezug auf die vollständige Breite und Höhe des Bilds. Es gibt insgesamt 4 * Anzahl von Rois pro Zeile.
0 |rois 0.2185 0.0 0.165 0.29 ...
  1. train.roilabels.txt (CNTK-Textformat) enthält in jeder Zeile zuerst eine Sequenznummer, dann den |roiLabels Bezeichner, gefolgt von einer Sequenz von Zahlen. Dies sind Gruppen von Zahlenzahlen (entweder Null oder 1) pro ROI, die die Boden-Wahrheitsklasse in einer 1-heißen Darstellung codieren. Es gibt eine Gesamtzahl der Bezeichnungen * Anzahl von Rois pro Zeile.
0 |roiLabels 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0  ...

Algorithmusdetails

SchnelleS R-CNN

R-CNNs für die Objekterkennung wurden 2014 von Ross Girshick et al. vorgestellt und wurden gezeigt, dass frühere state-of-the-art-Ansätze auf einem der wichtigsten Objekterkennungsprobleme im Feld ausstehen: Pascal VOC. Seitdem wurden zwei Nachverfolgungspapiere veröffentlicht, die erhebliche Geschwindigkeitsverbesserungen enthalten: Fast R-CNN und Faster R-CNN.

Die Grundidee von R-CNN besteht darin, ein tiefes neurales Netzwerk zu nehmen, das ursprünglich für die Bildklassifizierung mit Millionen von annotierten Bildern trainiert wurde und ihn zum Zweck der Objekterkennung ändert. Die Grundidee aus dem ersten R-CNN-Papier wird in der nachstehenden Abbildung (aus dem Papier) dargestellt: (1) In einem ersten Schritt werden in einem ersten Schritt eine große Anzahl von Bereichsvorschlägen generiert. (3) Diese Regionsvorschläge oder Regionen von Interessen (ROIs) werden dann unabhängig vom Netzwerk gesendet, das einen Vektor von z. B. 4096 Gleitkommawerten für jeden ROI ausgibt. Schließlich wird (4) ein Klassifizierer gelernt, der die 4096-Float-ROI-Darstellung als Eingabe verwendet und eine Bezeichnung und Vertrauen für jeden ROI ausgibt.

Bild

Während dieser Ansatz in Bezug auf Genauigkeit gut funktioniert, ist es sehr kostspielig, zu berechnen, da das neurale Netzwerk für jeden ROI ausgewertet werden muss. Schnelle R-CNN adressiert diesen Nachteil, indem nur die meisten Netzwerkebenen ausgewertet werden (um spezifisch zu sein: die Konvolutionsebenen) eine einzelne Zeit pro Bild. Laut den Autoren führt dies zu einer Geschwindigkeit von 213 Mal während der Tests und einer 9x Geschwindigkeit während der Schulung ohne Genauigkeitsverlust. Dies wird durch Die Verwendung einer ROI-Pooling-Ebene erreicht, die den ROI auf die konvolutionale Featurezuordnung angibt und die maximale Poolung ausführt, um die gewünschte Ausgabegröße zu generieren, die die folgende Ebene erwartet. Im in diesem Lernprogramm verwendeten AlexNet-Beispiel wird die ROI-Pooling-Ebene zwischen der letzten konvolutionalen Ebene und der ersten vollständig verbundenen Ebene platziert (siehe BrainScript-Code).

Die ursprüngliche Caffe-Implementierung, die in den R-CNN-Dokumenten verwendet wird, finden Sie unter GitHub: RCNN, Fast R-CNN und Faster R-CNN. Dieses Lernprogramm verwendet einige der Code aus diesen Repositorys, insbesondere (aber nicht ausschließlich) für DIE SVM-Schulung und Modellbewertung.

SVM vs NN-Schulung

Patrick Buehler bietet Anweisungen zum Trainieren eines SVM auf der CNTK Fast R-CNN-Ausgabe (mit den 4096-Features aus der letzten vollständig verbundenen Ebene) sowie eine Diskussion über Pros und Cons hier.

Selektive Suche ist eine Methode zum Suchen eines großen Satz möglicher Objektspeicherorte in einem Bild, unabhängig von der Klasse des tatsächlichen Objekts. Es funktioniert durch Gruppieren von Bildpixeln in Segmente, und führen Sie dann hierarchische Clustering aus, um Segmente aus demselben Objekt in Objektvorschläge zu kombinieren.

Bildbild

Um die erkannten ROIs aus der selektiven Suche zu ergänzen, fügen wir ROIs hinzu, die das Bild bei verschiedenen Skalierungen und Seitenverhältnissen einheitlich abdecken. Das erste Bild zeigt eine Beispielausgabe der selektiven Suche, bei der jeder mögliche Objektspeicherort durch ein grünes Rechteck visualisiert wird. ROIs, die zu klein sind, zu groß usw. werden verworfen (zweite Abbildung) und schließlich ROIs, die das Bild einheitlich abdecken (drittes Bild). Diese Rechtecks werden dann als Regions-of-Interests (ROIs) in der R-CNN-Pipeline verwendet.

Das Ziel der ROI-Generation besteht darin, eine kleine Gruppe von ROIs zu finden, die jedoch so viele Objekte im Bild wie möglich abdecken. Diese Berechnung muss ausreichend schnell sein, während gleichzeitig Objektstandorte in unterschiedlichen Skalierungen und Seitenverhältnissen gefunden werden. Die selektive Suche wurde gezeigt, dass diese Aufgabe gut ausgeführt wird, und zwar mit guter Genauigkeit, um Die Handelsabschläge zu beschleunigen.

NMS (Nicht maximale Unterdrückung)

Objekterkennungsmethoden geben häufig mehrere Erkennungen aus, die dasselbe Objekt in einem Bild vollständig oder teilweise abdecken. Diese ROIs müssen zusammengeführt werden, um Objekte zu zählen und ihre genauen Speicherorte im Bild abzurufen. Dies wird traditionell mithilfe einer Technik namens "Non Maximum Suppression" (NMS) durchgeführt. Die von uns verwendete NMS-Version (und die auch in den R-CNN-Publikationen verwendet wurde) führt keine ROIs zusammen, sondern versucht stattdessen zu identifizieren, welche ROIs die tatsächlichen Speicherorte eines Objekts abdecken und alle anderen ROIs verwerfen. Dies wird durch die iterative Auswahl des ROI mit höchster Vertrauenswürdigkeit implementiert und alle anderen ROIs entfernt, die diesen ROI erheblich überlappen und für dieselbe Klasse klassifiziert werden. Der Schwellenwert für die Überschneidung kann in PARAMETERS.py (Details) festgelegt werden.

Erkennungsergebnisse vor (erstes Bild) und nach (zweitem Bild) Nicht maximale Unterdrückung:

Bildbild

mAP (mitteldurchschnittliche Genauigkeit)

Sobald er trainiert wurde, kann die Qualität des Modells mithilfe verschiedener Kriterien gemessen werden, z. B. Genauigkeit, Rückruf, Genauigkeit, Bereichskurve usw. Eine allgemeine Metrik, die für die Pascal VOC-Objekterkennungs-Herausforderung verwendet wird, besteht darin, die Durchschnittliche Genauigkeit (AP) für jede Klasse zu messen. Die folgende Beschreibung der Durchschnittliche Genauigkeit wird von Everingham et al. genommen. Die mittlere Mittelwertgenauigkeit (mAP) wird berechnet, indem der Durchschnitt über die APs aller Klassen genommen wird.

Für eine bestimmte Aufgabe und Klasse wird die Genauigkeits-/Rückrufkurve aus der rangierten Ausgabe einer Methode berechnet. Der Rückruf wird als Anteil aller positiven Beispiele definiert, die über einer bestimmten Rangfolge bewertet wurden. Genauigkeit ist der Anteil aller Beispiele oberhalb dieser Rangfolge, die aus der positiven Klasse stammen. Die AP fasst die Form der Genauigkeits-/Rückrufkurve zusammen und wird als mittlere Genauigkeit bei einer Reihe von elf gleich leer gestellten Rückrufstufen definiert [0,0.1, . . . ,1]:

image

Die Genauigkeit auf jeder Rückrufstufe r wird interpoliert, indem die maximale Genauigkeit für eine Methode verwendet wird, für die der entsprechende Rückruf r überschreitet:

image

wobei p( ̃r) die gemessene Genauigkeit bei Rückruf ̃r ist. Die Absicht, die Genauigkeits-/Rückrufkurve auf diese Weise zu interpolieren, besteht darin, die Auswirkungen der "Wiggles" in der Genauigkeits-/Rückrufkurve zu verringern, die durch kleine Variationen in der Bewertung von Beispielen verursacht wird. Es sollte darauf hingewiesen werden, dass eine Methode eine hohe Bewertung erhalten soll, eine Methode auf allen Rückrufebenen präzise sein muss – dies bestraft Methoden, die nur eine Teilmenge von Beispielen mit hoher Genauigkeit abrufen (z. B. Seitenansichten von Autos).