create_dl_layer_box_targets — Erstellen eines Layers zur Generierung von Box-Targets.
create_dl_layer_box_targets( : : DLLayerBoxProposal, DLLayerGTBox, DLLayerGTMask, LayerNames, InputMode, OutputModes, NumClasses, GenParamName, GenParamValue : DLLayerBoxTargetsClsTarget, DLLayerBoxTargetsClsWeight, DLLayerBoxTargetsBoxTarget, DLLayerBoxTargetsBoxWeight, DLLayerBoxTargetsNumFgInstances, DLLayerBoxTargetsAssignedIdxs, DLLayerBoxTargetsMaskWeight)
Der Operator create_dl_layer_box_targets erzeugt Layer zur
Generierung von Box-Targets und gibt die entsprechenden
Layer-Handles zurück, siehe unten.
Diese generierten Box-Targets können z.B. zur Box-Klassifikation
oder in einem Box-Regression-Loss verwendet werden.
Dieser Layer erwartet mehrere zuführende Eingabelayer:
DLLayerBoxProposal: Enthält die Boxes, für die die
Targets berechnet werden sollen.
DLLayerGTBox: Enthält die Ground-Truth-Boxes für alle
Bilder innerhalb dieses Batches.
DLLayerGTMask (optional): Enthält die Ground-Truth-Masken
für alle Bilder innerhalb dieses Batches.
Diese Eingabe ist erforderlich, wenn das Modell auch Instanzmasken
vorhersagt (vgl. OutputModes 'mask_weight').
Andernfalls, wenn Instanzmasken nicht von Interesse sind, kann ein
leeres Tupel gesetzt werden.
Abhängig von OutputModes werden unterschiedliche
Ausgabelayer aus DLLayerBoxProposal abgeleitet und
für jeden davon muss in LayerNames ein Name
angegeben werden. Es ist zu beachten, dass beim Erstellen eines Modells mit
create_dl_model jeder Layer des erstellten Netzes einen
eindeutigen Namen haben muss.
Die Länge von LayerNames muss der Länge in OutputModes
mal der Länge von DLLayerBoxProposal entsprechen. Layer, die
für alle Ebenen gelten und daher nicht für jede Ebene ausgegeben werden
(vergleiche den entsprechenden Eintrag in der Beschreibung von
OutputModes),
werden von dieser Multiplikation ausgenommen und einzeln aufaddiert.
LayerNames sollte in der Reihenfolge angegeben werden, die den
Ausgabelayern entspricht, also
DLLayerBoxTargetsClsTarget,
DLLayerBoxTargetsClsWeight,
DLLayerBoxTargetsBoxTarget,
DLLayerBoxTargetsBoxWeight,
DLLayerBoxTargetsNumFgInstances,
DLLayerBoxTargetsAssignedIdxs,
DLLayerBoxTargetsMaskWeight.
Beispiel: für zwei Ebenen (2,3) und OutputModes =
['cls_target', 'cls_weight', 'num_fg_instances']:
['cls_t_l2', 'cls_t_l3', 'cls_w_l2', 'cls_w_l3', 'num_fg_instances'].
Der Parameter InputMode bestimmt die Art der erwarteten Eingaben in
DLLayerBoxProposal.
Die folgenden Werte sind möglich:
Die Eingabe-Boxes in DLLayerBoxProposal
sollen Anchors sein, z.B. aus einem Anchors-Layer, der mit
create_dl_layer_anchors erzeugt wurde.
In DLLayerBoxProposal können Anchors aus mehreren Merkmalskarten
angegeben werden.
Die Eingabe-Boxes in
DLLayerBoxProposal sollen Box-Proposals sein, z.B. aus einem
Box-Proposal-Layer, der mit create_dl_layer_box_proposals
erzeugt wurde.
Abhängig von OutputModes werden die folgenden Loss-Targets berechnet:
Die Zielklasse für jede Eingabe-Box. Im folgenden Schema sind die Regeln für die Zuweisung der Eingabe-Boxes zu den Ground-Truth-Boxes oder dem Hintergrund dargestellt.
Die Class-Targets hängen von InputMode ab:
'anchors' Die Class-Targets sind One-Hot-kodiert gegeben
und damit geeignet für einen Focal-Loss-Layer
(create_dl_layer_loss_focal).
'box_proposals': Die Class-Targets werden als Klassenindex
gegeben und sind damit geeignet für einen Softmax- gefolgt von einem
Cross-Entropy-Layer (create_dl_layer_softmax,
create_dl_layer_loss_cross_entropy).
Das Class-Loss-Gewicht für jede
Eingabe-Box. Klassengewichte und Klassenziele haben die gleiche Form,
so dass sie zusammen als zuführende Layer für den Class-Loss
verwendet werden können.
Die Klassengewichte werden in Abhängigkeit von den Class-Targets gesetzt
(siehe 'cls_target' oben).
Für Vorder- und Hintergrund-Boxes wird das
Gewicht auf 1.0 gesetzt, während für zu ignorierende Boxes das
Gewicht auf 0.0 gesetzt wird, so dass diese Boxes bei der
Loss-Berechnung nicht berücksichtigt werden.
Wenn InputMode 'box_proposals' ist, werden die Gewichte
für alle Boxes mit der Fläche Null auf 0 gesetzt.
Für alle Boxes, die dem
Vordergrund zugeordnet werden (siehe 'cls_target' oben), werden
die Box-Delta-Targets als Koordinatendifferenzen zu den zugeordneten
Ground-Truth-Boxes berechnet, so dass sie als Eingaben für einen
nachfolgenden Loss-Layer, z.B. ein Huber-Loss-Layer
(create_dl_layer_loss_huber), verwendet werden können.
Für Hintergrund- oder zu ignorierende Boxes werden die Targets auf
0 gesetzt.
Die Box-Delta-Targets hängen von 'instance_type' ab:
'rectangle1': Die Box-Delta-Targets () werden folgendermaßen berechnet: wobei die Eingabeboxparameter und die Ground-Truth-Boxparameter sind.
'rectangle2':
Die Box-Delta-Targets ()
werden folgendermaßen berechnet:
wobei die Eingabeboxparameter, die
Ground-Truth-Boxparameter und ()
die mit 'inside_center_weight',
'inside_dimension_weight' und 'inside_angle_weight'
gegebenen Innengewichte sind.
korrigiert den Winkel in das entsprechende Intervall, das
davon abhängt, ob die Richtung des Objekts innerhalb der Box
berücksichtigt wird. Dieses Verhalten wird durch den Parameter
'ignore_direction' bestimmt,
siehe get_dl_model_param und unten.
Wenn 'ignore_direction' 'false' ist, haben die Boxes
Orientierungen im Bereich , sonst im Bereich
.
Für alle Boxes, die dem Vordergrund zugeordnet werden (siehe 'cls_target' oben), werden die Gewichte auf 'center_weight' für , 'dimension_weight' für oder (je nach 'instance_type') und 'angle_weight' für gesetzt, sonst auf 0.0.
Diese Ausgabe enthält einen Skalar mit
der Anzahl der Vordergrund-Boxes (siehe 'cls_target' oben)
des gesamten Eingabe-Batches. Er kann z.B. als Normalisierungswert
innerhalb eines nachfolgenden Focal-Loss-Layers
(create_dl_layer_loss_focal) verwendet werden.
Es ist zu beachten, dass der gleiche Ausgabewert für alle Elemente
innerhalb eines Batches gegeben wird.
Es ist außerdem zu beachten, dass es auch bei mehreren Anchor-Stufen
nur einen Ausgabelayer DLLayerBoxTargetsNumFgInstances gibt.
Diese Ausgabe enthält den Index der
zugewiesenen Ground-Truth-Box für alle Vordergrund-Boxes (siehe
'cls_target' oben). Für alle anderen Boxes wird der Ausgabewert
auf -1 gesetzt. Dieser Modus ist nur verfügbar für InputMode
'box_proposals'. Die Ausgabe kann zur Berechnung von Masken-Targets
genutzt werden, wobei ein ROI-Pooling-Layer
(create_dl_layer_roi_pooling) auf die Ground-Truth-Masken
angewendet wird.
Diese Ausgabe enthält die Gewichte für einen
nachfolgenden Mask-Prediction-Loss
(siehe z.B. create_dl_layer_loss_distance). Jeder Kanal hat die
Dimensionen 'mask_width' mal 'mask_height'. In jedem Kanal
in dem der entsprechend zugeordnete Index (siehe 'assigned_idxs'
oben) größer oder gleich 0.0 ist, werden alle Werte auf
1.0 gesetzt, ansonsten auf 0.0.
Das Maskengewicht wird ebenso auf 0.0 gesetzt, wenn eine
Ground-Truth-Box-Instanz keine Ground-Truth-Maske enthält.
Dies ermöglicht das Trainieren mit Datensätzen,
bei denen nicht alle Boxes auch mit Instanzmasken annotiert sind.
Doppelte Einträge in OutputModes werden ignoriert.
Wenn eine leere Liste angegeben wird, werden alle verfügbaren Optionen
aktiviert.
NumClasses soll auf die Anzahl der Klassen gesetzt werden, die im
Datensatz (ohne Hintergrund) enthalten sind, oder auf 1, wenn die
Class-Targets für den Ausgabemodus 'cls_target' klassenagnostisch
berechnet werden sollen.
Dies ist z.B. in einem Region-Proposal-Netzwerk der Fall, das die
erste Stufe der Faster R-CNN-Architektur bildet (siehe Referenzen unten).
In diesem letzteren Fall werden alle Ground-Truth-Boxes als zu einer
einzigen Kategorie 'Objekt' zugehörig interpretiert.
Die folgenden generischen Parameter GenParamName und die
entsprechenden Werte GenParamValue werden unterstützt:
Außengewicht-Multiplikator für Box-Winkel (phi), der für die Ausgabe von 'box_weight' verwendet wird.
Restriktion: Nur anwendbar für 'instance_type' 'rectangle2'.
Default: 1.0.
Bestimmt, ob die 'box_target' und 'box_weight'
Ausgaben klassenspezifisch sind ('true') oder nicht
('false').
Wenn ja, werden die Targets und Gewichte nur innerhalb des
Tiefe-Index gesetzt, der der Zielklasse entspricht.
Restriktion:
Nur anwendbar auf InputMode
'box_proposals' und wenn OutputModes
'box_target' verwendet wird.
Default: 'false'.
Außengewicht-Multiplikator für die Box-Mittelpunkt-Koordinaten , der für die Ausgabe von 'box_weight' verwendet wird.
Default: 1.0.
Außengewicht-Multiplikator für die Box-Dimensionen (für 'instance_type' 'rectangle1') und (für 'instance_type' 'rectangle2'), der für die Ausgabe von 'box_weight' verwendet wird.
Default: 1.0.
Negativer Schwellenwert für den Vordergrund. Anchors, die zu jeder Ground-Truth-Box eine IoU kleiner als diesem Schwellenwert haben, werden dem Hintergrund zugewiesen. Über 'set_weak_boxes_to_bg' kann gesteuert werden, ob dennoch ein Anchor einer Vordergrund-Klasse zugeordnet werden soll (siehe unten). Siehe obiges Schema für detaillierte Erklärungen.
Default: 0.4.
Positiver Schwellenwert für den Vordergrund. Anchors, die zu irgendeiner Ground-Truth-Box ein IoU größer oder gleich diesem Schwellenwert haben werden dem Vordergrund zugewiesen. Siehe obiges Schema für detaillierte Erklärungen.
Default: 0.5.
Bestimmt, ob die Boxes vom Typ 'rectangle2' die Richtung des Objekts innerhalb der Box beachten:
'true': Die Orientierung der 'rectangle2'-Boxes liegt im Bereich .
'false': Die Orientierung der 'rectangle2'-Boxes liegt im Bereich .
Restriktion: Nur anwendbar für 'instance_type' 'rectangle2'.
Default: 'false'.
Innengewicht-Multiplikator für die Box-Winkel (phi), der für die Ausgabe von 'box_target' verwendet wird.
Restriktion: Nur anwendbar für 'instance_type' 'rectangle2'.
Default: 1.0.
Innengewicht-Multiplikator für die Box-Mittelpunkt-Koordinaten , der für die Ausgabe von 'box_target' verwendet wird.
Default: 1.0.
Innengewicht-Multiplikator für die Box-Dimensionen (für 'instance_type' 'rectangle1') und (l1, l2) (für 'instance_type' 'rectangle2'), der für die Ausgabe von 'box_target' verwendet wird.
Default: 1.0.
Instanztyp der 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'
Legt fest, ob die Ausgabe von 'mask_weight' klassenspezifisch
angegeben wird. Für 'true' wird die
die Ausgabe von 'mask_weight' so angegeben, dass nur
das Gewicht in der Zielklasse (entsprechend dem Tiefe-Index)
auf 1 gesetzt wird.
Restriktion:
Nur anwendbar, wenn OutputModes
'mask_weight' verwendet wird.
Default: 'false'.
Ausgabehöhe des Maskengewichtslayers im Ausgabemodus 'mask_weight'.
Default: 1.
Ausgabebreite des Maskengewichtslayers im Ausgabemodus 'mask_weight'.
Default: 1.
Maximale Anzahl von zufällig ausgewählten Targets mit Gewichten, die auf einen Wert größer als 0 eingestellt sind, pro Batch-Element.
Restriktion:
Nur für InputMode
'box_proposals'.
Default: 256.
Zielverhältnis von Vordergrund- zu Hintergrund-Boxes bei zufälligem Box-Sampling. Mit 'cls_weight' = 1 ist die maximale Anzahl an Vordergrund-Vorschlägen 'max_num_samples' mal 'ratio_num_fg'. Die verbleibenden bis zu 'max_num_samples' Vorschläge sind Hintergrund-Vorschläge, falls so viele vorhanden sind.
Restriktion:
Nur für InputMode
'box_proposals'.
Default: 0.25.
Bestimmt, ob vorhergesagte Boxes eine IoU größer als 'fg_neg_thresh' erreichen müssen, um möglicherweise einer Ground-Truth-Box zugeordnet zu werden oder ob diese automatisch dem Hintergrund zugeordnet werden (siehe obiges Schema):
'true': Anchors mit einem IoU kleiner 'fg_neg_thresh' werden automatisch dem Hintergrund zugeordnet.
'false': mindestens die vorhergesagte Box mit der höchsten IoU wird als Vordergrund und damit als positives Beispiel gesetzt, unabhängig vom IoU-Wert.
Default: 'false'.
Bestimmte Parameter von Layern, die mit create_dl_layer_box_targets
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' (DLLayerBoxProposal, DLLayerGTBox, DLLayerGTMask) |
x
|
|
'name' (LayerNames) |
x |
x
|
'output_layer' (DLLayerBoxTargetsClsTarget, DLLayerBoxTargetsClsWeight) |
x
|
|
| 'shape' | x
|
|
| 'type' | x
|
| Generische Layer-Parameter | set |
get
|
|---|---|---|
| 'angle_weight' | x |
x
|
| 'box_cls_specific' | x
|
|
| 'center_weight' | x |
x
|
| 'dimension_weight' | x
|
|
| 'fg_neg_thresh' | x |
x
|
| 'fg_pos_thresh' | x |
x
|
| 'ignore_direction' | x
|
|
'input_mode' (InputMode) |
x
|
|
| 'inside_angle_weight' | x
|
|
| 'inside_center_weight' | x
|
|
| 'inside_dimension_weight' | x
|
|
| 'is_inference_output' | x |
x
|
| 'instance_type' | x
|
|
| 'mask_cls_specific' | x |
x
|
| 'mask_height' | x |
x
|
| 'mask_width' | x |
x
|
| 'max_num_samples' | x |
x
|
'num_classes' (NumClasses) |
x |
x
|
| 'num_trainable_params' | x
|
|
| 'ratio_num_fg' | x |
x
|
| 'set_weak_boxes_to_bg' | x |
x
|
DLLayerBoxProposal (input_control) dl_layer(-array) → (handle)
Zuführende Layer mit Box-Proposals oder Anchors für die Targets berechnet werden sollen.
DLLayerGTBox (input_control) dl_layer → (handle)
Zuführende Layer mit Ground-Truth-Boxes.
DLLayerGTMask (input_control) dl_layer → (handle)
Zuführende Layer mit Ground-Truth-Masken (optional).
LayerNames (input_control) string(-array) → (string)
Namen der Ausgabelayer.
InputMode (input_control) string → (string)
Modus der Eingabe-Boxes.
Default: 'box_proposals'
Werteliste: 'anchors', 'box_proposals'
OutputModes (input_control) string-array → (string)
Modi welche Ausgaben berechnet werden sollen.
Werteliste: 'assigned_idxs', 'box_target', 'box_weight', 'cls_target', 'cls_weight', 'mask_weight', 'num_fg_instances'
NumClasses (input_control) number → (integer)
Anzahl Klassen.
Restriktion:
NumClasses > 0
GenParamName (input_control) attribute.name(-array) → (string)
Namen der generischen Eingabeparameter.
Default: []
Werteliste: 'angle_weight', 'box_cls_specific', 'center_weight', 'dimension_weight', 'fg_neg_thresh', 'fg_pos_thresh', 'ignore_direction', 'inside_angle_weight', 'inside_center_weight', 'inside_dimension_weight', 'instance_type', 'is_inference_output', 'mask_cls_specific', 'mask_height', 'mask_width', 'max_num_samples', 'ratio_num_fg', 'set_weak_boxes_to_bg'
GenParamValue (input_control) attribute.value(-array) → (string / integer / real)
Werte der generischen Eingabeparameter.
Default: []
Wertevorschläge: 'rectangle1', 'rectangle2', 'true', 'false', 0.4, 0.5, 256, 0.25, 1.0, 7, 14
DLLayerBoxTargetsClsTarget (output_control) dl_layer(-array) → (handle)
Class-Target-Layer.
DLLayerBoxTargetsClsWeight (output_control) dl_layer(-array) → (handle)
Klassengewichts-Layer.
DLLayerBoxTargetsBoxTarget (output_control) dl_layer(-array) → (handle)
Box-Target-Layer.
DLLayerBoxTargetsBoxWeight (output_control) dl_layer(-array) → (handle)
Box-Weight-Layer.
DLLayerBoxTargetsNumFgInstances (output_control) dl_layer → (handle)
NumFgInstances-Layer.
DLLayerBoxTargetsAssignedIdxs (output_control) dl_layer → (handle)
Layer der zugewiesenen Indizes.
DLLayerBoxTargetsMaskWeight (output_control) dl_layer → (handle)
Mask-Weight-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_convolution,
create_dl_layer_anchors,
create_dl_layer_box_proposals
create_dl_layer_box_proposals,
create_dl_layer_loss_focal,
create_dl_layer_loss_huber
create_dl_layer_box_proposals,
create_dl_layer_loss_focal,
create_dl_layer_loss_huber
Shaoqing Ren, Kaiming He, Ross B. Girshick, and Jian Sun, "Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks," IEEE Transactions on Pattern Analysis and Machine Intelligence, Volume 39, Number 6, pp. 1137--1149, 2017, doi: 10.1109/TPAMI.2016.2577031.
Deep Learning Professional