create_dl_layer_box_proposals — Erstellen eines Layer zur Generierung von Box-Proposals.
create_dl_layer_box_proposals( : : DLLayerClassScore, DLLayerBoxDelta, DLLayerBox, DLLayerInputImage, LayerName, GenParamName, GenParamValue : DLLayerBoxProposals)
Der Operator create_dl_layer_box_proposals erzeugt einen Layer
zur Generierung von Box-Proposals, dessen Handle in
DLLayerBoxProposals zurückgegeben wird.
Dieser Layer erwartet mehrere zuführende Eingabelayer:
DLLayerClassScore: Enthält den vorhergesagten Score
für jede Eingabebox und -klasse,
DLLayerBoxDelta (optional): Enthält die Box-Delta-Werte
die von einem Box-Regressionslayer vorhergesagt wurden (siehe
create_dl_layer_box_targets),
DLLayerBox: Enthält die Eingabeboxkoordinaten und
DLLayerInputImage: Enthält den Bild-zuführenden Layer
des Netzwerks oder einen beliebigen anderen Layer der dieselben
Dimensionen (bzgl. Breite und Höhe) aufweist wie die
Eingabebilder.
Der Parameter LayerName legt einen individuellen Layernamen fest.
Es ist zu beachten, dass beim Erstellen eines Modells mit
create_dl_model jeder Layer des erstellten Netzes einen
eindeutigen Namen haben muss.
Der Box-Proposal-Layer verarbeitet die Eingabe-Boxes in den folgenden Schritten (siehe auch die detaillierte Beschreibung der generischen Parameter weiter unten):
Für jedes Eingabefeld in DLLayerBox wird der
entsprechende Score in DLLayerClassScore als Box-Konfidenz gesetzt.
Wenn DLLayerClassScore Scores für mehr als eine Klasse enthält,
wird eine Box für jede Klasse erstellt, bei der der Score den Wert
'min_confidence' übersteigt und die Klassen-ID, die zum
Klassenindex gehört, wird als Ausgabeklassen-ID festgelegt.
Alle Boxes mit einem Score kleiner als 'min_confidence' werden
entfernt.
Während des Trainings wird der Schwellenwert 'min_confidence_train'
anstelle von 'min_confidence' verwendet. Ein niedrigerer Wert
erlaubt es mehr Boxes an nachfolgende Abschnitte des Netzwerks
weiterzuleiten. Die maximal 'max_num_pre_nms' Boxes pro
Eingabe mit dem höchsten Score werden für die folgenden
Netzwerkabschnitte behalten.
Wenn Box-Deltas in
DLLayerBoxDelta gegeben sind und 'apply_box_regression'
auf 'true' gesetzt ist, werden Box-Deltas auf die Eingabe-Boxes
angewendet, die durch DLLayerBox gegeben sind.
Bevor sie angewendet werden, werden die Box-Deltas
durch die inverse Funktion transformiert, da ihre Box-Targets in
create_dl_layer_box_targets transformiert werden.
Koordinaten müssen subpixel-genau angegeben werden.
Wenn ein leeres Tupel anDLLayerBoxDelta übergeben wird,
werden die Box-Koordinaten wie in DLLayerBox angegeben
beibehalten.
Für jede Box B, die nicht von einer anderen Box unterdrückt wurde, werden alle anderen Boxes B', die nicht unterdrückt wurden, dieselbe Klassen-ID haben, einen niedrigeren Score haben und einen Quotient aus Schnittmenge und Vereinigungsmenge (IoU, von engl. intersection over union) von mindestens 'max_overlap' mit B haben, unterdrückt.
Für jede Box B, die nicht von einer anderen Box unterdrückt wurde, werden alle anderen Boxes B', die nicht unterdrückt wurden, einen niedrigeren Score haben und einen IoU von mindestens 'max_overlap_class_agnostic' mit B haben, unterdrückt.
Nach der Durchführung der NMS, werden von den verbleibenden Boxes die maximal 'max_num_post_nms' mit den höchsten Scores ausgegeben (Gesamtanzahl über alle Eingaben). Sind dabei weniger als 'max_num_post_nms' Boxes innerhalb eines Batch-Elements vorhanden, werden die restlichen Ausgabewerte mit Nullen aufgefüllt.
Für jede Box enthält die Ausgabe deren Parameter, ihren Klassenindex und
ihren Score in dieser Reihenfolge. Die Box-Parameter sind abhängig von
'instance_type':
4 für 'rectangle1' (row1, column1, row2,
column2) bzw.
5 für 'rectangle2' (row, column, phi,
length1, length2).
Daher entspricht die Tiefe der Ausgabe der maximalen Anzahl von
Boxes pro Batch-Element 'max_num_post_nms', die Höhe
entspricht der Anzahl der Boxparameter plus zwei
(für Klassenindex und Score), und die Breite ist gleich eins.
Die subpixel-genauen Koordinaten (pixel-zentriert, siehe
Transformationen / 2D-Transformationen) der Ausgabeboxes werden
in Bezug auf die Abmessungen des Eingabebildes angegeben.
Nach dem Erzeugen eines Netzes mit create_dl_model und dem Setzen des
Modelltyps auf 'detection' über set_dl_model_param,
wird der letzte Box-Proposal-Layer innerhalb des Netzes als Box-Ausgabelayer
verwendet: Dessen Ausgaben werden in Tupeln innerhalb des
Ergebnis-Dictionarys des Modells ausgegeben, ähnlich wie die Ausgaben eines
Detektion-Modells, das mit create_dl_model_detection erstellt wurde.
Das Ausgabe-Dictionary enthält:
Box-Parameter. Abhängig von 'instance_type' sind die Schlüssel:
'bbox_row1', 'bbox_col1', 'bbox_row2'
und 'bbox_col2' für
'instance_type' = 'rectangle1'.
'bbox_row', 'bbox_col', 'bbox_phi',
'bbox_length1' und 'bbox_length2' für
'instance_type' = 'rectangle2'.
Klassen-IDs. Schlüssel: 'bbox_class_id'
Scores. Schlüssel: 'bbox_confidence'
Für ein erstelltes Modell mit Typ 'detection' können die folgenden
Parameter (siehe deren Erklärung unten) des letzten Box-Proposal-Layers
innerhalb des Netzes mit den Operatoren set_dl_model_param bzw.
set_dl_model_layer_param gesetzt werden:
'max_num_detections' (überschreibt 'max_num_post_nms'),
'max_overlap',
'max_overlap_class_agnostic',
'min_confidence' und
'nms_pre_top_n_per_level' (überschreibt 'max_num_pre_nms').
Die folgenden generischen Parameter GenParamName und die
entsprechenden Werte GenParamValue werden unterstützt:
Auf 'false' gesetzt, wird die Box-Regression, also die Verfeinerung der Box-Positionen, nicht durchgeführt.
Default: 'true'.
Sollte auf 'true' gesetzt werden,
falls die Box-Deltas klassenspezifisch berechnet wurden, siehe
create_dl_layer_box_targets.
Default: 'false'.
Auf 'true' gesetzt werden Ausgabeboxes auf den Bildausschnitt zugeschnitten.
Restriktion: Nur für 'instance_type' = 'rectangle1'.
Default: 'false'.
Auf 'false' gesetzt, werden 'rectangle2'-Boxes im Intervall orientiert, andernfalls .
Restriktion: Nur für 'instance_type' = 'rectangle2'.
Default: 'false'.
Typ der zugrunde liegenden Box-Eingaben und Box-Deltas. Folgende Typen können gesetzt werden:
Die durch DLLayerBox angegebenen
Eingabe-Boxes sind Anchors, die z.B. mit
create_dl_layer_anchors erzeugt wurden.
In diesem Fall müssen sowohl die
Score-Eingaben als auch die optionalen Box-Delta-Eingaben die gleiche
Breite und Höhe wie die Anchors-Eingaben haben.
Die Tiefe der Score-Eingaben
ist vom Anchor-Typ und dem Klassenindex abhängig. Wenn also k
die Anzahl der Anchor-Typen (die Anzahl Subskalen mal die Anzahl
Seitenverhältnisse mal die Anzahl Winkel) ist und n die Anzahl
der Klassen, dann ist die Tiefe k mal n.
Die Reihenfolge ist die gleiche wie bei der Ausgabe der Class-Targets
des Box-Targets-Layers, d. h.,
(Anchor-Typ 0, Klassenindex 0),
(Anchor-Typ 0, Klassenindex 1), ...,
(Anchor-Typ 0, Klassenindex n-1), ...,
(Anchor-Typ k-1, Klassenindex 0),
(Anchor-Typ k-1, Klassenindex 1), ...,
(Anchor-Typ k-1, Klassenindex n).
Die Tiefe der Box-Delta-Eingaben entspricht der Anzahl
der Anchor-Typen mal der Anzahl der Box-Parameter (NBP),
d.h. k * NBP.
NBP hängt von 'instance_type' ab:
4 für 'rectangle1' (row1, column1,
row2, column2) bzw.
5 für 'rectangle2' (row, column, phi,
length1, length2).
Die Box-Delta-Eingaben und die Eingabe-Anchors sollten also die gleiche
Tiefe aufweisen und in gleicher Weise geordnet sein.
Wurde create_dl_layer_box_targets zum Erzeugen der Score- und
Box-Delta-Targets verwendet, ist die Reihenfolge automatisch korrekt.
DLLayerBox, DLLayerClassScore, und
DLLayerBoxDelta können Tupel von Layern mit
gleicher Länge sein, die gleichzeitig verarbeitet werden sollen.
Zum Beispiel kann jede Eingabe einer Ebene in einem
Merkmalspyramiden-Netzwerk entsprechen
(siehe die unten angegebenen Referenzen).
Die Eingabe-Boxes, die durch
DLLayerBox angegebenen werden sind Box-Proposals,
die z.B. mit einem anderen Box-Proposal-Layer generiert wurden.
In diesem Fall muss die Batchgröße der Score- und Box-Delta-Eingaben
gleich der Batchgröße der Box-Eingaben
mal der Tiefe der Box-Eingaben sein.
Diese Änderung der Batchgröße wird
durch einen ROI-Pooling-Layer (create_dl_layer_roi_pooling)
erreicht, die die Box-Proposals als Eingabe verwendet.
Die Tiefe der Score-Eingaben ist die Anzahl der Klassen plus
eins, da der erste Index als Hintergrundklasse interpretiert wird.
Die Tiefe der Box-Delta-Eingabe ist die Anzahl der
Box-Parameter (NBP), wenn 'box_cls_specific' =
'false', oder NBP mal der Anzahl der Klassen, wenn
'box_cls_specific' = 'true'.
Wurde create_dl_layer_box_targets zum Erzeugen der Score- und
Box-Delta-Targets verwendet, ist auch hier die Reihenfolge automatisch
korrekt.
Default: 'anchors'.
Innengewicht-Multiplikator für Box-Winkelkoordinaten (phi). Box-Winkel-Deltas werden durch diesen Wert geteilt, um die inneren Box-Gewichte in den Box-Targets zu berücksichtigen. Daher sollten die Werte mit den im Box-Targets-Layer eingestellten Werten übereinstimmen.
Restriktion: Nur für 'instance_type' 'rectangle2'. Default: 1.0.
Innengewicht-Multiplikator für Koordinaten der Boxmitte (Zeile und Spalte). Box-Mittelpunkt-Deltas werden durch diesen Wert geteilt, um die inneren Box-Gewichte im Box-Targets-Layer zu berücksichtigen. Daher sollten die Werte mit den im Box-Targets-Layer eingestellten Werten übereinstimmen.
Default: 1.0.
Innengewicht-Multiplikator für Box-Dimensionen (Breite und Höhe). Die Box-Dimensions-Deltas werden durch diesen Wert geteilt, um die inneren Box-Gewichte im Box-Targets-Layer zu berücksichtigen. Daher sollten die Werte mit den im Box-Targets-Layer eingestellten Werten übereinstimmen.
Default: 1.0.
Instanztyp der generierten Boxes. Mögliche Werte:
'rectangle1': achsenparallele Rechtecke.
'rectangle2': orientierte Rechtecke.
Default: 'rectangle1'.
Bestimmt, ob apply_dl_model die Ausgabe dieses Layers im
Dictionary DLResultBatch zurückgibt, auch ohne den
Layer in Outputs anzugeben ('true'), oder
nur falls er angegeben wird ('false').
Default: 'false'
Maximale Anzahl von Erkennungen nach
Anwendung von NMS. Wenn die Anzahl der Eingaben in
DLLayerClassScore mal 'max_num_pre_nms' größer ist,
wird dieser Wert verwendet.
Restriktion: Der angegebene Wert muss ganzzahlig und positiv sein.
Default: 1000.
Maximale Anzahl von Erkennungen pro
DLLayerClassScore-Eingabe, vor der Anwendung von NMS.
Restriktion: Der angegebene Wert muss ganzzahlig und positiv sein.
Default: 10000.
Maximal erlaubter Quotient aus Schnittmenge und Vereinigungsmenge (IoU) zweier Boxes der gleichen Klasse. Klassenspezifische NMS kann deaktiviert werden, indem dieser Wert auf 1.0 gesetzt wird.
Default: 0.7.
Maximal erlaubter Quotient aus Schnittmenge und Vereinigungsmenge (IoU) zweier Boxes beliebiger Klassen. Klassenagnostische NMS kann deaktiviert werden, indem dieser Wert auf 1.0 gesetzt wird.
Default: 1.0.
Boxes, bei denen mindestens eine der Seitenlänge größer als der gesetzte Schwellenwert sind, werden verworfen.
Mögliche Werte:
Für 'instance_type' 'rectangle1' werden die Schwellenwerte für die Höhe der Boxes auf das 1,5-fache der Bildhöhe und die Breite der Boxes auf das 1,5-fache der Bildbreite gesetzt.
Für 'instance_type' 'rectangle2' wird sowohl für die Breite als auch die Höhe der Boxes der Schwellenwert auf das Zweifache des Maximums von Bildbreite und -höhe gesetzt.
Legt die maximal zulässige Seitenlänge manuell fest.
Es wird kein Schwellenwert verwendet.
Restriktion: Muss größer oder gleich Null sein oder 'default' oder 'none'.
Default: 'default'.
Boxes mit einer Konfidenz kleiner als diesem Wert werden bei der Inferenz verworfen.
Default: 0.5.
Boxes mit einer Konfidenz kleiner als diesem Wert werden beim Training verworfen.
Default: 0.05.
Boxes, bei denen mindestens eine der Seitenlängen kleiner als dieser Wert sind, werden verworfen. Restriktion: Muss größer oder gleich Null sein.
Default: 0.0.
Legt fest, welche IoU für die Berechnung der NMS verwendet wird. Mögliche Werte:
Exakte IoU.
Winkelbezogene IoU. Die winkelbezogene IoU ist
für zwei 'rectangle2'-Boxes A und B definiert
als der Kosinus ihres Zwischenwinkels mal dem 'rectangle1'
IoU von und B, wobei die
an der Box B ausgerichtete Box A ist.
Siehe auch create_dl_layer_box_targets.
Restriktion: Nur anwendbar für 'instance_type' 'rectangle2'.
Default: 'exact'.
Legt fest, welcher Typ von NMS verwendet wird. Mögliche Werte:
Eine Box wird verworfen, wenn es sich mit einer anderen Box mit höherem Score überschneidet.
Soft NMS wird angewendet. Das bedeutet, dass eine Box nicht verworfen wird, wenn sie sich mit einer anderen Box mit höherem Score überschneidet. Stattdessen wird ihr Score in Abhängigkeit vom Wert der IoU der besser bewerteten Box reduziert, siehe 'soft_nms_type' und die unten angegebenen Referenzen.
Default: 'standard'.
Definiert, wie der Score im Falle von 'nms_type' = 'soft' aktualisiert wird. Mögliche Werte:
Iterativ bewirkt jede Box eine Skalierung der Box-Konfidenzen aller anderen Boxes mit geringerer Konfidenz um einen Faktor von 1 - IoU, falls die IoU der Boxen größer ist als 'max_overlap' bzw. 'max_overlap_class_agnostic'.
Iterativ bewirkt jede Box eine Skalierung der Box-Konfidenzen aller anderen Boxes mit geringerer Konfidenz um einen Faktor von wobei durch 'max_overlap' bzw. 'max_overlap_class_agnostic' gegeben ist.
Default: 'linear'.
Bestimmte Parameter von Layern, die mit create_dl_layer_box_proposals
erzeugt wurden, können mit weiteren Operatoren gesetzt und abgerufen werden.
Die folgenden Tabellen geben einen Überblick, welche Parameter mit
set_dl_model_layer_param gesetzt werden können und welche mit
get_dl_model_layer_param oder get_dl_layer_param ausgelesen
werden können. Es ist zu beachten, dass die Operatoren
set_dl_model_layer_param und get_dl_model_layer_param ein
Modell benötigen, das mit create_dl_model erzeugt wurde.
| Layer-interne Parameter | set |
get
|
|---|---|---|
'input_layer' (DLLayerClassScore, DLLayerBoxDelta, DLLayerBox, and/or DLLayerInputImage) |
x
|
|
'name' (LayerName) |
x |
x
|
'output_layer' (DLLayerBoxProposals) |
x
|
|
| 'shape' | x
|
|
| 'type' | x
|
| Generische Layer-Parameter | set |
get
|
|---|---|---|
| 'apply_box_regression' | x |
x
|
| 'box_cls_specific' | x
|
|
| 'clip_boxes' | x |
x
|
| 'has_box_regression_inputs' | x
|
|
| 'ignore_direction' | x
|
|
| 'input_mode' | x
|
|
| 'inside_angle_weight' | x
|
|
| 'inside_center_weight' | x
|
|
| 'inside_dimension_weight' | x
|
|
| 'is_inference_output' | x |
x
|
| 'instance_type' | x
|
|
| 'max_overlap' | x |
x
|
| 'max_overlap_class_agnostic' | x |
x
|
| 'max_num_post_nms' | x
|
|
| 'max_num_pre_nms' | x |
x
|
| 'max_overlap' | x |
x
|
| 'max_overlap_class_agnostic' | x |
x
|
| 'max_num_post_nms' | x
|
|
| 'max_num_pre_nms' | x |
x
|
| 'max_side_length' | x |
x
|
| 'min_confidence' | x |
x
|
| 'min_confidence_train' | x |
x
|
| 'min_side_length' | x |
x
|
| 'nms_mode' | x
|
|
| 'nms_type' | x |
x
|
| 'num_class_ids_no_orientation' | x
|
|
| 'num_trainable_params' | x
|
|
| 'soft_nms_type' | x |
x
|
DLLayerClassScore (input_control) dl_layer(-array) → (handle)
Zuführende Layer mit Klassifizierungs-Scores.
DLLayerBoxDelta (input_control) dl_layer(-array) → (handle)
Zuführende Layer mit Bounding Box-Regressions-Werten.
DLLayerBox (input_control) dl_layer(-array) → (handle)
Zuführende Layer mit Anchors oder Eingabe-Box-Proposals.
DLLayerInputImage (input_control) dl_layer → (handle)
Zuführende Layer mit Eingabebildern des Netzes.
LayerName (input_control) string → (string)
Name des Ausgabelayers.
GenParamName (input_control) attribute.name(-array) → (string)
Namen der generischen Eingabeparameter.
Default: []
Werteliste: 'apply_box_regression', 'box_cls_specific', 'clip_boxes', 'ignore_direction', 'input_mode', 'inside_angle_weight', 'inside_center_weight', 'inside_dimension_weight', 'instance_type', 'is_inference_output', 'max_num_post_nms', 'max_num_pre_nms', 'max_overlap', 'max_overlap_class_agnostic', 'max_side_length', 'min_confidence', 'min_confidence_train', 'min_side_length', 'nms_mode', 'nms_type', 'soft_nms_type'
GenParamValue (input_control) attribute.value(-array) → (string / integer / real)
Werte der generischen Eingabeparameter.
Default: []
Wertevorschläge: 'rectangle1', 'rectangle2', 'dense', 'anchors', 'standard', 'soft', 'exact', 'arIoU', 'linear', 'gaussian', 'true', 'false', 'default', 'none', 0.05, 0.5, 1.0, 0.7, 10.0, 5.0, 2000
DLLayerBoxProposals (output_control) dl_layer → (handle)
Box-Proposals-Layer.
* Minimal example for the usage of layers
* - create_dl_layer_box_proposals
* - create_dl_layer_box_targets
* for creating and training a model to perform object detection.
*
dev_update_off ()
NumClasses := 1
AnchorAspectRatios := 1.0
AnchorNumSubscales := 1
* Define the input image layer.
create_dl_layer_input ('image', [224,224,3], [], [], DLLayerInputImage)
* Define the input ground truth box layers.
create_dl_layer_input ('bbox_row1', [1, 1, 10], ['allow_smaller_tuple'], \
['true'], DLLayerInputRow1)
create_dl_layer_input ('bbox_row2', [1, 1, 10], ['allow_smaller_tuple'], \
['true'], DLLayerInputRow2)
create_dl_layer_input ('bbox_col1', [1, 1, 10], ['allow_smaller_tuple'], \
['true'], DLLayerInputCol1)
create_dl_layer_input ('bbox_col2', [1, 1, 10], ['allow_smaller_tuple'], \
['true'], DLLayerInputCol2)
create_dl_layer_input ('bbox_label_id', [1, 1, 10], \
['allow_smaller_tuple'], ['true'], \
DLLayerInputLabelID)
create_dl_layer_class_id_conversion (DLLayerInputLabelID, \
'class_id_conversion', \
'from_class_id', [], [], \
DLLayerClassIdConversion)
* Concatenate all box coordinates.
create_dl_layer_concat ([DLLayerInputRow1, DLLayerInputCol1, \
DLLayerInputRow2, DLLayerInputCol2, \
DLLayerClassIdConversion], \
'gt_boxes', 'height', [], [], DLLayerGTBoxes)
*
* Perform some operations on the input image to extract features.
* -> this serves as our backbone CNN here.
create_dl_layer_convolution (DLLayerInputImage, 'conv1', 3, 1, 2, 8, 1, \
'half_kernel_size', 'relu', [], [], \
DLLayerConvolution)
create_dl_layer_convolution (DLLayerConvolution, 'conv2', 3, 1, 2, 8, 1, \
'half_kernel_size', 'relu', [], [], \
DLLayerConvolution)
create_dl_layer_pooling (DLLayerConvolution, 'pool', 2, 2, 'none', \
'maximum', [], [], DLLayerPooling)
*
* Create the anchor boxes -> adapt the scale to fit the object size.
create_dl_layer_anchors (DLLayerPooling, DLLayerInputImage, 'anchor', \
AnchorAspectRatios, AnchorNumSubscales, [], \
['scale'], [8], DLLayerAnchors)
*
* Create predictions for the classification and regression of anchors.
* We set the bias such that background is a lot more likely than foreground.
PriorProb := 0.05
BiasInit := -log((1.0 - PriorProb) / PriorProb)
create_dl_layer_convolution (DLLayerPooling, 'cls_logits', 3, 1, 1, \
NumClasses, 1, 'half_kernel_size', 'none', \
['bias_filler_const_val'], \
[BiasInit], DLLayerClsLogits)
create_dl_layer_convolution (DLLayerPooling, 'box_delta_predictions', 5, 1, \
1, 4*|AnchorAspectRatios|*|AnchorNumSubscales|, \
1, 'half_kernel_size', 'none', [], [], \
DLLayerBoxDeltaPredictions)
*
* Generate the class and box regression targets for the anchors
* according to the ground truth boxes.
* -> we use inside-weights here, they also need to be set in the
* corresponding box proposals layer later.
Targets := ['cls_target', 'cls_weight', 'box_target', 'box_weight', \
'num_fg_instances']
create_dl_layer_box_targets (DLLayerAnchors, DLLayerGTBoxes, [], Targets, \
'anchors', Targets, NumClasses, \
['inside_center_weight', \
'inside_dimension_weight'], [10.0, 5.0], \
DLLayerClassTarget, DLLayerClassWeight, \
DLLayerBoxTarget, DLLayerBoxWeight, \
DLLayerNumFgInstances, _, _)
*
* We use a focal loss for the classification predictions.
create_dl_layer_loss_focal (DLLayerClsLogits, DLLayerClassTarget, \
DLLayerClassWeight, DLLayerNumFgInstances, \
'loss_cls', 1.0, 2.0, 0.25, \
'sigmoid_focal_binary', [], [], DLLayerLossCls)
* We use an L1-loss for the box deltas.
create_dl_layer_loss_huber (DLLayerBoxDeltaPredictions, DLLayerBoxTarget, \
DLLayerBoxWeight, [], 'loss_box', 1.0, 0.0, [], [], DLLayerLossBox)
*
* Apply sigmoid to class-predictions and compute box outputs.
* --> alternatively, we could directly apply the prediction and set the
* focal loss mode to 'focal_binary' instead of 'sigmoid_focal_binary'.
create_dl_layer_activation (DLLayerClsLogits, 'cls_probs', 'sigmoid', \
[], [], DLLayerClsProbs)
create_dl_layer_box_proposals (DLLayerClsProbs, DLLayerBoxDeltaPredictions, \
DLLayerAnchors, DLLayerInputImage, \
'anchors', ['inside_center_weight', \
'inside_dimension_weight'], [10.0, 5.0], \
DLLayerBoxProposals)
*
* Create the model.
OutputLayers := [DLLayerLossCls, DLLayerLossBox, DLLayerBoxProposals]
create_dl_model (OutputLayers, DLModelHandle)
*
* Prepare the model for using it as a detection model.
set_dl_model_param (DLModelHandle, 'type', 'detection')
ClassIDs := [2]
set_dl_model_param (DLModelHandle, 'class_ids', ClassIDs)
set_dl_model_param (DLModelHandle, 'max_overlap', 0.1)
*
* Create a sample.
create_dict (DLSample)
gen_image_const (Image, 'real', 224, 224)
gen_circle (Circle, [50., 100.], [50., 150.], [20., 20.])
overpaint_region (Image, Circle, [255], 'fill')
compose3 (Image, Image, Image, Image)
set_dict_object (Image, DLSample, 'image')
smallest_rectangle1 (Circle, Row1, Col1, Row2, Col2)
set_dict_tuple (DLSample, 'bbox_row1', Row1)
set_dict_tuple (DLSample, 'bbox_row2', Row2)
set_dict_tuple (DLSample, 'bbox_col1', Col1)
set_dict_tuple (DLSample, 'bbox_col2', Col2)
set_dict_tuple (DLSample, 'bbox_label_id', [2,2])
*
* Train the model for some iterations (heavy overfitting).
set_dl_model_param (DLModelHandle, 'learning_rate', 0.0001)
Iteration := 0
TotalLoss := 1e6
LossCls := 1e6
LossBox := 1e6
dev_inspect_ctrl ([Iteration, TotalLoss, LossCls, LossBox])
while (TotalLoss > 0.2 and Iteration < 3000)
train_dl_model_batch (DLModelHandle, DLSample, DLResult)
get_dict_tuple (DLResult, 'loss_cls', LossCls)
get_dict_tuple (DLResult, 'loss_box', LossBox)
get_dict_tuple (DLResult, 'total_loss', TotalLoss)
Iteration := Iteration + 1
endwhile
dev_close_inspect_ctrl ([Iteration, TotalLoss, LossCls, LossBox])
*
* Apply the detection model.
apply_dl_model (DLModelHandle, DLSample, [], DLResult)
*
* Display ground truth and result.
create_dict (DLDatasetInfo)
set_dict_tuple (DLDatasetInfo, 'class_ids', ClassIDs)
set_dict_tuple (DLDatasetInfo, 'class_names', ['circle'])
create_dict (WindowHandleDict)
dev_display_dl_data (DLSample, DLResult, DLDatasetInfo, \
['image', 'bbox_ground_truth', 'bbox_result'], [], \
WindowHandleDict)
stop ()
dev_close_window_dict (WindowHandleDict)
create_dl_layer_box_targets,
create_dl_layer_roi_pooling,
create_dl_layer_anchors
Tsung-Yi Lin, Piotr Dollàr, Ross B. Girshick, Kaiming He,
Bharath Hariharan, and Serge J. Belongie,
"Feature Pyramid Networks for Object Detection,"
2017 IEEE Conference on Computer Vision and Pattern Recognition (CVPR),
Honolulu, HI, USA, 2017, pp. 936--944,
doi: 10.1109/CVPR.2017.106.,
Navaneeth Bodla, Bharat Singh, Rama Chellappa, and Larry S. Davis,
SSoft-NMS - Improving Object Detection with One Line of Code,"
2017 IEEE International Conference on Computer Vision (ICCV),
Venice, Italy, 2017, pp. 5562--5570,
doi: 10.1109/ICCV.2017.593.
Deep Learning Professional