Objekterkennung mit schnellerer R-CNN

Inhaltsverzeichnis

• Zusammenfassung
• Schnellstart
  • Ausführen des Toy-Beispiels
• Schrittweise Anleitungen
  • Einrichtung
  • Konfiguration und Parameter
  • Schnelleren R-CNN auf Pascal VOC ausführen
  • Schnelleren R-CNN auf Ihren eigenen Daten ausführen
• Technische Details
  • Regionsvorschlagsnetzwerk
  • Reader- und Minibatchquelle
  • E2E- und 4-Phasen-Schulung
  • Verwenden eines anderen Basismodells

Zusammenfassung

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

Schneller R-CNN ist ein Objekterkennungsalgorithmus, der von Shaoqing Ren, Kaiming He, Ross Girshick und Jian Sun im Jahr 2015 vorgeschlagen wird. Das Forschungspapier lautet "Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks", und wird archiviert unter https://arxiv.org/abs/1506.01497. Schnellerer 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 setzt Schneller R-CNN ein Regionsvorschlagsnetzwerk ein und erfordert keine externe Methode für Kandidatenregionenvorschläge.

Dieses Lernprogramm ist in drei Hauptabschnitte strukturiert. Der erste Abschnitt enthält eine präzise Beschreibung der Ausführung schnellerer R-CNN in CNTK im bereitgestellten Beispieldatensatz. Der zweite Abschnitt enthält Details zu allen Schritten, einschließlich Setup und Parameterisierung von Faster R-CNN. Im letzten Abschnitt werden technische Details des Algorithmus und des Regionsvorschlagsnetzwerks erläutert, die Eingabedaten lesen und erweitern sowie verschiedene Schulungsoptionen für schnellere R-CNN.

Schnellstart

In diesem Abschnitt wird davon ausgegangen, dass Ihr System für die Verwendung der CNTK Python-API eingerichtet ist. Wir gehen weiter davon aus, dass Sie Python 3.5 unter Windows oder 3.5/3.6 unter Linux verwenden. Eine ausführliche Anleitung finden Sie in den Schrittweisen Anleitungen. Um schneller R-CNN auszuführen, installieren Sie bitte die folgenden zusätzlichen Pakete in Ihrer cntk Python-Umgebung.

pip install opencv-python easydict pyyaml

Ausführen des Toy-Beispiels

Wir verwenden ein Toy-Dataset von Bildern, die aus einem Kühlschrank erfasst wurden, um schnellere R-CNN zu demonstrieren (dasselbe wie für das Beispiel fast R-CNN). Sowohl das Dataset als auch das vorab trainierte AlexNet-Modell können heruntergeladen werden, indem Sie den folgenden Python-Befehl aus dem Ordner "Beispiele/Image/Detection/FastRCNN" ausführen:

python install_data_and_model.py

Nach dem Ausführen des Skripts wird das Toy-Dataset unter dem Examples/Image/DataSets/Grocery Ordner installiert. Das AlexNet-Modell wird in den PretrainedModels Ordner heruntergeladen. Es wird empfohlen, die heruntergeladenen Daten im jeweiligen Ordner beizubehalten, da die Konfigurationsdateien standardmäßig davon ausgehen, dass dieser Speicherort standardmäßig vorhanden ist.

So trainieren und bewerten Sie schneller R-CNN-Ausführung

python run_faster_rcnn.py

Die Ergebnisse für End-to-End-Schulungen auf Lebensmittelgeschäft mit AlexNet als Basismodell sollten wie folgt aussehen:

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

So visualisieren Sie die vorhergesagten Begrenzungsfelder und Beschriftungen auf den Bildern, die aus dem FasterRCNN Ordner geöffnet FasterRCNN_config.py sind, und legen Sie fest

__C.VISUALIZE_RESULTS = True

Die Bilder werden im FasterRCNN/Output/Grocery/ Ordner gespeichert, wenn Sie ausführen python run_faster_rcnn.py.

Schrittweise Anweisungen

Einrichten

Um den Code in diesem Beispiel auszuführen, benötigen Sie eine CNTK Python-Umgebung (siehe hier , um Hilfe zur Einrichtung zu erhalten). Installieren Sie die folgenden zusätzlichen Pakete in Ihrer cntk Python-Umgebung

pip install opencv-python easydict pyyaml

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

Der Ordner Examples\Image\Detection\utils\cython_modules enthält vorab kompilierte Binärdateien, die für die Ausführung schnellerer R-CNN erforderlich sind. Die derzeit im Repository enthaltenen Versionen sind Python 3.5 für Windows und Python 3.5, 3.6 für Linux, alle 64 Bit. Wenn Sie eine andere Version benötigen, können Sie sie kompilieren, wenn Sie die schritte ausführen, die unter

• Linux: https://github.com/rbgirshick/py-faster-rcnn
• Windows: https://github.com/MrGF/py-faster-rcnn-windows

Kopieren Sie die generierten cython_bbox und cpu_nms (und/oder gpu_nms) Binärdateien von $FRCN_ROOT/lib/utils zu $CNTK_ROOT/Examples/Image/Detection/utils/cython_modules.

Beispieldaten und Basismodell

Wir verwenden ein vorab trainiertes AlexNet-Modell als Basis für die Schneller-R-CNN-Schulung (für VGG oder andere Basismodelle siehe Verwenden eines anderen Basismodells). Sowohl das Beispiel-Dataset als auch das vorab trainierte AlexNet-Modell können heruntergeladen werden, indem sie den folgenden Python-Befehl aus dem FastRCNN-Ordner ausführen:

python install_data_and_model.py

• Erfahren Sie, wie Sie ein anderes Basismodell verwenden
• Erfahren Sie, wie Sie schnellere R-CNN auf Pascal VOC-Daten ausführen
• Erfahren Sie, wie Sie schneller R-CNN auf ihren eigenen Daten ausführen.

Konfiguration und Parameter

Die Parameter werden in drei Teile gruppiert:

• Detektorparameter (siehe FasterRCNN/FasterRCNN_config.py)
• Parameter des Datasets (siehe Beispiel utils/configs/Grocery_config.py)
• Basismodellparameter (siehe Beispiel utils/configs/AlexNet_config.py)

Die drei Teile werden geladen und in der get_configuration() Methode zusammengeführt.run_faster_rcnn.py In diesem Abschnitt werden die Detektorparameter behandelt. Hier werden Die Parameter des Datasets beschrieben, basismodellparameter hier. Im Folgenden durchlaufen wir den Inhalt FasterRCNN_config.py von oben nach unten. Die Konfiguration verwendet das EasyDict Paket, das einfachen Zugriff auf geschachtelte Wörterbücher ermöglicht.

# If set to 'True' training will be skipped if a trained model exists already
__C.CNTK.MAKE_MODE = False
# E2E or 4-stage training
__C.CNTK.TRAIN_E2E = True
# set to 'True' to use deterministic algorithms
__C.CNTK.FORCE_DETERMINISTIC = False
# set to 'True' to run only a single epoch
__C.CNTK.FAST_MODE = False
# Debug parameters
__C.CNTK.DEBUG_OUTPUT = False
__C.CNTK.GRAPH_TYPE = "png" # "png" or "pdf"
# Set to True if you want to store an eval model with native UDFs (e.g. for inference using C++ or C#)
__C.STORE_EVAL_MODEL_WITH_NATIVE_UDF = False

Der erste Parameterblock enthält Anweisungen auf höherer Ebene bezüglich des Schulungsprozesses. __C.CNTK.TRAIN_E2E ermöglicht die Auswahl des End-to-End- oder 4-Phasen-Schulungsschemas. Details zu den beiden Schulungsprogrammen werden hier beschrieben. __C.CNTK.FAST_MODE = True führt nur eine einzige Epoche aus; Es ist nützlich, zu testen, ob das Setup funktioniert und alle Parameter korrekt sind. __C.CNTK.DEBUG_OUTPUT = True generiert zusätzliche Debugmeldung in der Konsolenausgabe. Außerdem werden CNTK-Berechnungsdiagramme sowohl für die Schulungs- als auch für dieVal-Modelle gezeichnet (beachten Sie die Anforderungen für das Zeichnen von CNTK-Diagrammen). Die resultierenden Diagramme werden im FasterRCNN/Output Ordner gespeichert. __C.STORE_EVAL_MODEL_WITH_NATIVE_UDF = True speichert ein zweites Auswertungsmodell, das nur systemeigenen Code (keine Python-Ebenen) verwendet. Dieses Modell kann beispielsweise aus C++ oder C# geladen und ausgewertet werden.

# Learning parameters
__C.CNTK.L2_REG_WEIGHT = 0.0005
__C.CNTK.MOMENTUM_PER_MB = 0.9
# The learning rate multiplier for all bias weights
__C.CNTK.BIAS_LR_MULT = 2.0

# E2E learning parameters
__C.CNTK.E2E_MAX_EPOCHS = 20
__C.CNTK.E2E_LR_PER_SAMPLE = [0.001] * 10 + [0.0001] * 10 + [0.00001]

Der zweite Block enthält die Lernparameter. Dies sind meist normale CNTK-Lernparameter. Die einzige Ausnahme ist __C.CNTK.BIAS_LR_MULTdie Lernrate multiplizierer, die für alle Verzerrungen im Netzwerk verwendet wird. Es trainiert im Wesentlichen die Verzerrungen mit zweimal der aktuellen Lernrate, die auch im ursprünglichen R-CNN-Code durchgeführt wird. Die Anzahl der Epochen und lernrate pro Stichprobe wird separat für die beiden verschiedenen Lernschemas angegeben (4-Phasen-Parameter, die oben nicht angegeben werden).

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

# Sigma parameter for smooth L1 loss in the RPN and the detector (DET)
__C.SIGMA_RPN_L1 = 3.0
__C.SIGMA_DET_L1 = 1.0

# NMS threshold used to discard overlapping predicted bounding boxes
__C.RESULTS_NMS_THRESHOLD = 0.5
# all bounding boxes with a score lower than this threshold will be considered background
__C.RESULTS_NMS_CONF_THRESHOLD = 0.0

# Enable plotting of results generally / also plot background boxes / also plot unregressed boxes
__C.VISUALIZE_RESULTS = False
__C.DRAW_NEGATIVE_ROIS = False
__C.DRAW_UNREGRESSED_ROIS = False
# only for plotting results: boxes with a score lower than this threshold will be considered background
__C.RESULTS_BGR_PLOT_THRESHOLD = 0.1

__C.INPUT_ROIS_PER_IMAGE Gibt die maximale Anzahl von Grund-Wahrheitsanmerkungen pro Bild an. CNTK muss derzeit eine maximale Zahl festlegen. Wenn weniger Anmerkungen vorhanden sind, werden sie intern gepolstert. __C.IMAGE_WIDTH und __C.IMAGE_HEIGHT sind die Dimensionen, die verwendet werden, um die Größe und das Pad der Eingabebilder zu ändern. __C.RESULTS_NMS_THRESHOLD ist der NMS-Schwellenwert, der zum Verwerfen von überlappenden umgebenden Feldern in der Auswertung verwendet wird. Ein niedrigerer Schwellenwert führt zu weniger Entfernungen und somit mehr vorhergesagten Begrenzungsfeldern in der endgültigen Ausgabe.

# 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

# RPN parameters
# IOU >= thresh: positive example
__C.TRAIN.RPN_POSITIVE_OVERLAP = 0.7
# IOU < thresh: negative example
__C.TRAIN.RPN_NEGATIVE_OVERLAP = 0.3
# If an anchor statisfied by positive and negative conditions set to negative
__C.TRAIN.RPN_CLOBBER_POSITIVES = False
# Max number of foreground examples
__C.TRAIN.RPN_FG_FRACTION = 0.5
# Total number of examples
__C.TRAIN.RPN_BATCHSIZE = 256
# NMS threshold used on RPN proposals
__C.TRAIN.RPN_NMS_THRESH = 0.7
# Number of top scoring boxes to keep before apply NMS to RPN proposals
__C.TRAIN.RPN_PRE_NMS_TOP_N = 12000
# Number of top scoring boxes to keep after applying NMS to RPN proposals
__C.TRAIN.RPN_POST_NMS_TOP_N = 2000
# Proposal height and width both need to be greater than RPN_MIN_SIZE (at orig image scale)
__C.TRAIN.RPN_MIN_SIZE = 16

__C.TRAIN.USE_FLIPPED = True erweitert die Schulungsdaten, indem alle Bilder alle anderen Epochen gedreht werden, d. h. die erste Epoche hat alle regulären Bilder, die zweite hat alle Bilder gedreht usw. __C.TRAIN_CONV_LAYERS bestimmt, ob die konvolutionalen Ebenen, von eingaben bis zur konvolutionalen Featurezuordnung, trainiert oder behoben werden. Das Beheben der Konvschichtgewichte bedeutet, dass die Gewichte aus dem Basismodell genommen und nicht während des Trainings geändert werden. (Sie können auch angeben, wie viele Konvebenen Sie trainieren möchten, siehe Abschnitt Mit einem anderen Basismodell). Für die rpn-Parameter lesen Sie bitte die Kommentare neben ihrer Definition, oder konsultieren Sie das ursprüngliche Forschungspapier, um weitere Details zu erhalten. Auch für die folgenden Detektorparameter:

# Detector parameters
# Minibatch size (number of regions of interest [ROIs]) -- was: __C.TRAIN.BATCH_SIZE = 128
__C.NUM_ROI_PROPOSALS = 128
# Fraction of minibatch that is labeled foreground (i.e. class > 0)
__C.TRAIN.FG_FRACTION = 0.25
# Overlap threshold for an ROI to be considered foreground (if >= FG_THRESH)
__C.TRAIN.FG_THRESH = 0.5
# Overlap threshold for an ROI to be considered background (class = 0 if
# overlap in [LO, HI))
__C.TRAIN.BG_THRESH_HI = 0.5
__C.TRAIN.BG_THRESH_LO = 0.0

# Normalize the targets using "precomputed" (or made up) means and stdevs
__C.BBOX_NORMALIZE_TARGETS = True
__C.BBOX_NORMALIZE_MEANS = (0.0, 0.0, 0.0, 0.0)
__C.BBOX_NORMALIZE_STDS = (0.1, 0.1, 0.2, 0.2)

Schnelleren R-CNN auf Pascal VOC ausführen

Um die Pascal-Daten herunterzuladen und die Anmerkungsdateien für Pascal im CNTK-Format zu erstellen, führen Sie die folgenden Skripts aus:

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

Ändern der dataset_cfg In-Methode get_configuration() in run_faster_rcnn.py

from utils.configs.Pascal_config import cfg as dataset_cfg

Jetzt legen Sie fest, dass Sie die Pascal VOC 2007-Daten verwenden python run_faster_rcnn.py. Achten Sie darauf, dass die Schulung eine Weile dauern kann.

Schnelleren R-CNN auf eigenen Daten ausführen

Die Vorbereitung Ihrer eigenen Daten und das Annotieren mit Boden-Wahrheitsbindungsfeldern wird in der Objekterkennung mithilfe von Fast R-CNN beschrieben. Führen Sie nach dem Speichern Ihrer Bilder in der beschriebenen Ordnerstruktur aus, und melden Sie sich bitte an.

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

nach dem Ändern des Ordners in diesem Skript in Ihren Datenordner. Erstellen Sie schließlich einen MyDataSet_config.py in dem utils\configs Ordner, der den vorhandenen Beispielen folgt, wie in diesem Codeausschnitt:

...

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

...

__C.CNTK.PROPOSAL_LAYER_SCALES wird in generate_anchors() (siehe utils/rpn/generate_anchors.py) verwendet. Ab einer Basisgröße von 16 drei Ankern mit Seitenverhältnis 0.5, 1.0 und 2.0 entsteht (8 x 24, 16 x 16, 24 x 8). Dies wird mit jeder Vorschlagsschichtskala multipliziert, die neun Anker (64 x 192, ... , 768 x 256). Dies sind absolute Pixelkoordinaten w.r.t. das Eingabebild. Alle Anker werden an jeder räumlichen Position der konvolutionalen Featurekarte angewendet, um Kandidatenregionen von Interesse zu generieren. Passen Sie diese Vorschlagsebenenskala entsprechend den Objektgrößen in Ihrem Datensatz und der von Ihnen verwendeten Eingabebildgröße an. Beispiel: Für den Lebensmitteldatensatz, den wir verwenden __C.DATA.PROPOSAL_LAYER_SCALES = [4, 8, 12] , und eine Eingabebildgröße 850 x 850 (siehe utils/configs/Grocery_config.py).

So trainieren und bewerten Sie schneller R-CNN für Ihre Daten ändern sich dataset_cfg in der get_configuration() Methode von run_faster_rcnn.py

from utils.configs.MyDataSet_config import cfg as dataset_cfg

und ausführen python run_faster_rcnn.py.

Technische Details

Als die meisten DNN-basierten Objektdetektoren verwendet Schneller R-CNN Transfer Learning. Es beginnt mit einem Basismodell, das ein Modell ist, das für die Bildklassifizierung trainiert ist. Das Basismodell wird in zwei Teile ausgeschnitten, die erste, die alle verwvolutigen Schichten bis zu (und ausschließen) die letzte Poolingschicht und der zweite Teil ist der Rest des Netzwerks von (und außer) der letzten Poolingschicht bis zu (wieder außer) der endgültigen Vorhersageschicht. Die Ausgabe des ersten Teils wird manchmal als konvolutionale Featurezuordnung bezeichnet. Dies wird als Eingabe für die ROI-Pooling-Ebene verwendet, die einen Poolvorgang in einem Teil der Eingabezuordnung ausführt, der Regionsvorschlägen im ursprünglichen Bild entspricht. Die Regionenvorschläge sind eine zweite Eingabe für die ROI-Pooling-Ebene. In Schnelleren R-CNN werden diese Vorschläge durch ein kleines Unternetzwerk namens Region Vorschlagsnetzwerk (RPN, siehe nächster Abschnitt) generiert.

Die Ausgabe der ROI-Pooling-Ebene verfügt immer über die gleiche feste Größe, da sie alle Eingaben (konvolutionale Featurezuordnung + Region-Vorschlag) mit derselben Ausgabegröße zusammengibt. Beachten Sie, dass die Eingabegröße, d. h. die Größe der konvolutionalen Featute-Karte und somit auch die Eingabebildgröße beliebig sein kann. Für die Schulung verwendet der Algorithmus vier Verlustfunktionen, zwei für das RPN und zwei für den Detektor (siehe auch nächster Abschnitt). Die folgende Methode ist in FasterRCNN_train.py enthalten und zeigt die hohe Konstruktion des Schnelleren R-CNN-Modells an. Bitte verweisen Sie auf FasterRCNN_train.py den vollständigen Code und utils/rpn/rpn_helpers.py den vollständigen Code.

def create_faster_rcnn_model(features, scaled_gt_boxes, dims_input, 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)

    # RPN and prediction targets
    rpn_rois, rpn_losses = create_rpn(conv_out, scaled_gt_boxes, dims_input, cfg)
    rois, label_targets, bbox_targets, bbox_inside_weights = \
        create_proposal_target_layer(rpn_rois, scaled_gt_boxes, cfg)

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

    return loss, pred_error

Nach dem Training wird das Netzwerk in ein Auswertungsmodell konvertiert, indem alle Teile entfernt werden, die für die Auswertung nicht erforderlich sind, z. B. die Verlustfunktionen. Das endgültige Auswertungsmodell verfügt über drei Ausgaben (siehe in create_faster_rcnn_eval_model()FasterRCNN_train.py weiteren Details):

• rpn_rois - die absoluten Pixelkoordinaten des Kandidaten-Rois
• cls_pred - die Klassenwahrscheinlichkeit für jeden ROI
• bbox_regr - die Regressionskoeffizienten pro Klasse für jeden ROI

Um das Auswertungsmodell von Python zu verwenden, können Sie das FasterRCNN_Evaluator von .FasterRCNN_eval.py Sie können das Modell einmal laden und dann einzelne Bilder auswerten, während Sie gehen. Die process_image() Methode des Evaluator verwendet einen Pfad zu einem Bild als Argument, bewertet das Modell auf diesem Bild und wendet die Begrenzungsfeldregression auf die resultierenden ROIs an. Es gibt die regressierten ROIs und die entsprechende Klassenwahrscheinlichkeit zurück:

    evaluator = FasterRCNN_Evaluator(model, cfg)
    regressed_rois, cls_probs = evaluator.process_image(img_path)

Bereichsvorschlagsnetzwerk

Schnellerer R-CNN verwendet einen sogenannten Regionsvorschlag netwrok (RPN), der Kandidatenregionen von Interesse (ROIs) basierend auf dem Eingabebild generiert. Dies ist gegen fast R-CNN, die Regionsvorschläge erfordern, die von einer externen Quelle bereitgestellt werden müssen. Das RPN wird im Wesentlichen durch drei Konvolutionsebenen und eine neue Ebene namens Vorschlagsschicht aufgebaut. Die neuen Ebenen werden als benutzerdefinierte Funktion (UDF) in Python oder C++ realisiert (siehe unten). Der Python-Code, der das RPN in CNTK erstellt, befindet utils/rpn/rpn_helpers.pysich in den neuen Ebenen wie der Vorschlagsschicht im utils/rpn Ordner.

Die Eingabe an das RPN ist die konvolutionale Featurezuordnung, dieselbe, die die Eingabe an die ROI-Pooling-Ebene darstellt. Diese Eingabe wird in die erste Konvolutionsebene des RPN eingespeist und das Ergebnis wird an die anderen beiden Konvolutionsebenen verteilt. Einer der letzteren prognostiziert Klassenbewertungen für jede Kandidatenregion, d. h. für jeden Anker an jeder räumlichen Position (9 Anker x 2 Bewertungen x Breite x Höhe). Die beiden Bewertungen werden (mithilfe eines Softmax-Knotens) in Objektheitsbewertungen pro Kandidaten konvertiert, die als Wahrscheinlichkeit eines Kandidatenbereichs interpretiert werden, um ein Vordergrundobjekt zu enthalten oder nicht. Die andere konvolutionale Schicht prognostiziert Regressionskoeffizienten für die tatsächliche Position des ROI, erneut für jeden Kandidaten (9 Anker x 4 Koeffizienten x Breite x Höhe).

Die Regressionskoeffizienten und die Objektheitsbewertungen (Vordergrund- und Hintergrundwahrscheinlichkeit) werden in die Vorschlagsebene eingespeist. Diese Ebene wendet zuerst die Regressionskoeffizienten auf die generierten Anker an, klammert das Ergebnis an die Bildgrenzen und filtert Kandidatenbereiche aus, die zu klein sind. Anschließend sortiert er die Kandidaten nach Vordergrundwahrscheinlichkeit, wendet nicht maximale Unterdrückung (NMS) an, um die Anzahl der Kandidaten zu verringern und schließlich die gewünschte Anzahl von ROIs für die Ausgabe zu untersuchen.

Während der Schulung erfordert R-CNN zwei zusätzliche neue Ebenen: die Ankerzielebene und die Vorschlagszielebene. Die Ankerzielebene generiert die Zielwerte für die Objektheitsbewertung und die RPN-Regressionskoeffizienten, die in den Verlustfunktionen des RPN verwendet werden. Ebenso generiert die Vorschlagszielebene die Zielklassenbezeichnungen für die ROIs und die Ziel-Regressionskoeffizienten pro Klasse für den endgültigen Detektor, der in den Verlustfunktionen des Detektors verwendet wird.

Während der Auswertung ist nur die Vorschlagsebene erforderlich (da keine Ziele für Verlustfunktionen erforderlich sind). Die Vorschlagsebene in CNTK ist in Python sowie C++verfügbar, die Zielebenen sind derzeit nur in Python verfügbar. Daher muss die Schulung schneller R-CNN derzeit aus der Python-API durchgeführt werden. So speichern Sie ein Auswertungsmodell nach dem Training, das den systemeigenen Implementierungssatz __C.STORE_EVAL_MODEL_WITH_NATIVE_UDF = Truefür Vorschlagsebene verwendet.

Lese- und Minibatchquelle

Wenn wir Bilder oder Flipbilder für die Datenerweiterung skalieren, müssen wir auch die gleichen Transformationen auf die Grund-Wahrheitsanmerkungen anwenden. (Das Flipping muss auch auf zwischengespeicherte Vorschläge in 4-Phasen-Schulung angewendet werden, siehe nächster Abschnitt.) Da diese verknüpften Transformationen von Bildern und Anmerkungen derzeit nicht von den integrierten CNTK-Lesern unterstützt werden, verwenden wir einen benutzerdefinierten Python-Reader und UserMinibatchSource einen für schnelleren R-CNN. Dies sind in utils/od_reader.py und utils/od_mb_source.py entsprechend enthalten.

E2E- und 4-Phasen-Schulung

Das Forschungspapier "Faster R-CNN" beschreibt zwei Methoden zum Trainieren des Netzwerks. End-to-End-Schulung trainiert das gesamte Netzwerk in einer einzigen Schulung mit allen vier Verlustfunktionen (rpn Regressionsverlust, rpn-Objektverlust, Detektor-Regressionsverlust, Detektorklassenverlust). Standardmäßig verwenden wir End-to-End-Schulung, sie können zwischen den beiden wählen, indem Sie entsprechend festlegen__C.CNTK.TRAIN_E2E.FasterRCNN_config.py

Das 4-Stufen-Schulungsschema wechselt zwischen dem Bereichsvorschlagsnetzwerk (wobei der Detektor festhält) und nur den Detektor (die RPN-Gewichte beheben). Dieses Schulungsschema wird in train_faster_rcnn_alternating()FasterRCNN_train.py. Es ist etwas aufwändiger und macht häufig die Verwendung von Kloningteilen des Modells, um Das Einfrieren und Training Gewichte selektiv zu ermöglichen. Außerdem werden in der 4-Phasen-Schulung die Vorschläge aus dem RPN nach Phasen 1 und drei gepuffert und in der nachfolgenden Phase verwendet.

Verwenden eines anderen Basismodells

Um ein anderes Basismodell zu verwenden, müssen Sie eine andere Modellkonfiguration in der get_configuration() Methode run_faster_rcnn.pyauswählen. Zwei Modelle werden sofort unterstützt:

    # 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

Um das VGG16-Modell herunterzuladen, verwenden Sie bitte das Downloadskript in <cntkroot>/PretrainedModels:

    python download_model.py VGG16_ImageNet_Caffe

Wenn Sie ein anderes Basismodell verwenden möchten, müssen Sie z. B. die Konfigurationsdatei utils/configs/VGG16_config.py kopieren und entsprechend Ihrem Basismodell ändern:

# 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

Um die Knotennamen Ihres Basismodells zu untersuchen, können Sie die plot() Methode verwenden cntk.logging.graph. Bitte beachten Sie, dass ResNet-Modelle derzeit nicht unterstützt werden, da die Roipooling in CNTK noch nicht unterstützt wird.