create_dl_layer_roi_pooling — Erstellen eines ROI-Pooling-Layers.
create_dl_layer_roi_pooling( : : DLLayerInputImage, DLLayerRoI, DLLayerFeature, DLLayerInstanceIndex, LayerName, Type, GridSize, GenParamName, GenParamValue : DLLayerRoIPooling)
Der Operator create_dl_layer_roi_pooling erzeugt einen
ROI-Pooling-Layer, dessen Handle in DLLayerRoIPooling
zurückgegeben wird.
Merkmale innerhalb der angegebenen ROIs werden
für die Weiterverarbeitung auf eine feste räumliche Ausgabedimension gepoolt.
Die räumliche Ausgabedimension ist gegeben durch GridSize.
Dieser Layer erwartet mehrere zuführende Eingabelayer:
DLLayerInputImage: Bestimmt den zuführenden Eingabelayer
der das Eingabebild des Netzwerks enthalten soll.
Er wird verwendet, um die Seitenverhältnisse (bezüglich Breite und Höhe)
der Merkmalskarten in Bezug auf die Dimensionen des Eingabebildes
abzuleiten.
DLLayerRoI: Bestimmt den zuführenden Eingabelayer,
der die Koordinaten der ROIs enthält. Die ROI-Koordinaten sollten
bezüglich des Eingabebildes angegeben werden und werden als pixelzentrierte
Koordinaten interpretiert (siehe
Transformationen / 2D-Transformationen).
Ein Layer hat die Form
[Breite, Höhe, Tiefe, Batchgröße],
wobei die Batchgröße veränderbar ist.
Für diesen Layer führt dies zu [1, NBP + 2, MNR,
'batch_size'] wobei MNR die maximale Anzahl von ROIs
für ein Bild und NBP die Anzahl der Box-Parameter ist.
NBP hängt vom Instanztyp 'instance_type' ab:
4 für 'rectangle1' (row1, column1, row2,
column2), bzw.
5 für 'rectangle2' (row, column, phi,
length1, length2).
Die zweite Dimension enthält neben den NBP-Rechteckparametern
zwei weitere Werte: Einen für die Klasse und einen für den
Score jeder ROI. Eine ROI wird ignoriert, wenn ihr Klassenwert negativ ist.
Wenn weniger als MNR ROIs vorhanden sind, sollten alle Koordinaten
auf Null gesetzt werden.
Dieser zuführende Layer ist normalerweise die Ausgabe eines
Box-Proposal-Layers (siehe create_dl_layer_box_proposals).
DLLayerFeature: Bestimmt den zuführenden Layer
der eine oder mehrere Merkmalskarten enthält, aus denen gepoolt werden soll.
Wenn mehr als eine Merkmalskarte angegeben wird, müssen sie nach
abnehmenden räumlichen Dimensionen geordnet werden.
Wenn zum Beispiel ein Feature Pyramid Network
(FPN) verwendet wird, bedeutet das, dass die Layer nach aufsteigender
FPN-Ebene geordnet werden.
Weitere detaillierte Informationen zum FPN und dessen Ebenen sind
im Kapitel Deep Learning / Objektdetektion und Instanz-Segmentierung oder in der weiter unten
folgenden Referenz zu finden.
DLLayerInstanceIndex: Bestimmt den zuführenden Eingabelayer,
der für jede ROI den Index der Ground-Truth-Instanz mit der höchsten
IoU enthält. Siehe create_dl_layer_box_targets für weitere
Informationen. Dieser Eingabelayer wird nur verwendet, wenn der
generische Parameter 'mode' = 'mask_target'.
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 ROI-Pooling-Vorgang läuft wie folgt ab:
Ein Gitter wird über jede ROI gelegt und die Merkmale innerhalb jeder
Gitterzelle werden gepoolt. Wie dies im Einzelnen geschieht, hängt
von Type ab:
Führt ein Max-Pooling durch, weshalb die berechneten Gitterkoordinaten auf pixelgenaue Koordinaten gerundet werden.
Für jeden Abtastpunkt wird der Wert durch bilineare Interpolation der vier benachbarten Pixel-Werte bestimmt. Der Ausgabewert für jede Gitterzelle ist der Mittelwert aus den Werten der Abtastpunkte. Die Anzahl der gleichmäßig verteilten Abtastpunkte in jeder Ausgabe-Gitterzelle wird durch 'sampling_ratio' bestimmt.
Die gepoolten Merkmale können zum Beispiel zur Vorhersage von Objektmasken innerhalb der gegebenen ROIs verwendet werden. In diesem Fall kann es sinnvoll sein, von einer etwas größeren ROI zu poolen, um die Wahrscheinlichkeit zu erhöhen, dass das Objekt vollständig in der ROI enthalten ist. Mit den generischen Parametern 'enlarge_box_factor_long' und 'enlarge_box_factor_short' kann die Skalierung der längeren und kürzeren Boxlängen vor dem Pooling gesteuert werden.
Bei mehreren Merkmalskarten werden die ROIs auf die Merkmalskarten entsprechend ihrer Größe nach der folgenden Formel verteilt:
wobei die ROI-Skalierung ist, berechnet als Quadratwurzel der ROI-Fläche. ist die kanonische FPN-Ebene und ist die kanonische FPN-Skalierung. Die kanonische FPN-Ebene und FPN-Skalierung können über die generischen Parameter 'fpn_roi_canonical_level' und 'fpn_roi_canonical_scale' eingestellt werden. wird zur Robustheit hinzugefügt und auf 1e-6 gesetzt.
Die folgenden generischen Parameter GenParamName und die
entsprechenden Werte GenParamValue werden unterstützt:
Faktor, mit dem die längere Seite der Box vor dem Pooling multipliziert wird.
Default: 1.0.
Faktor, mit dem die kürzere Seite der Box vor dem Pooling multipliziert wird.
Default: 1.0.
FPN-Level, dem die ROIs mit kanonischer Skalierung zugewiesen werden.
Default: 4.
ROIs mit dieser Skalierung werden der kanonischen Ebene zugewiesen.
Default: 224.
Typ der RoIs. 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'
Modus des Layers. Mögliche Werte:
'feature': Feature-Pooling.
DLLayerInputImage muss angegeben werden und
DLLayerInstanceIndex muss leer sein.
'mask_target': Erzeugung von Masken-Targets.
DLLayerInputImage muss leer sein und
DLLayerInstanceIndex muss angegeben werden.
In diesem Modus kann DLLayerFeature nur ein einzelner
Eingabelayer sein, dessen Bedeutung sich ändert.
Statt Merkmalskarten enthält DLLayerFeature die
Ground-Truth-Instanzmasken.
Der Layer hat die Form
['batch_size', MNI, IH, IW],
wobei MNI die maximale Anzahl von Instanzen in einem Bild ist,
und IH und IW die Höhe bzw. Breite der Netzwerkeingabe.
Jeder Kanal entspricht einer Ground-Truth-Instanz, wobei die Maske
im Binärformat kodiert ist.
Die Ausgabe des Layers enthält dann die zugeschnittenen und in der Größe
angepassten Masken-Targets, die zum Beispiel einem Focal-Loss-Layer
(siehe create_dl_layer_loss_focal) zusammen mit Maskenvorhersagen
zugeführt werden.
Default: 'feature'.
Die Anzahl vom Modell vorhergesagter Klassen. Dieser Parameter ist nur für 'mode' = 'mask_target' verfügbar.
Restriktion: Wird der Wert größer als 1 gesetzt, werden die Masken-Targets klassenspezifisch generiert. Dies wirkt sich auch auf die Ausgabeform des Layers aus, d.h., die Tiefe der Masken-Targets ist gleich 'num_classes'.
Default: 1.
Anzahl der Abtastpunkte, die über die Zellen-Höhe und -Breite einer Gitterzelle verteilt sind. Wird beispielsweise 'sampling_ratio' auf zwei gesetzt, gibt es vier Abtastpunkte in jeder Gitterzelle. Wenn 0 eingestellt ist, wird diese Anzahl automatisch berechnet.
Default: 0.
Dieser Wert legt einen Schwellenwert zwischen Null und Eins für die Ausgaben fest. Um den Schwellenwert zu deaktivieren kann dieser Wert auf -1 gesetzt werden.
Restriktion:
Nur verfügbar für 'mode' =
'mask_target' und Type = 'roi_align'.
Default: 0.5.
Folgende Parameter werden von create_dl_layer_roi_pooling nicht
unterstützt, da sie intern unter Verwendung von
DLLayerFeature berechnet werden:
Minimale FPN-Ebene, die für das Pooling verwendet wird.
Restriktion: Gilt nur für 'mode' 'feature'.
Default: 0.
Maximale FPN-Ebene, die für das Pooling verwendet wird.
Restriktion: Gilt nur für 'mode' 'feature'.
Default: 0.
Bestimmte Parameter von Layern, die mit create_dl_layer_roi_pooling
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-Parameter | set |
get
|
|---|---|---|
'grid_size' (GridSize) |
x
|
|
'input_layer' (DLLayerInputImage, DLLayerRoI, DLLayerFeature, and/or DLLayerInstanceIndex) |
x
|
|
'name' (LayerName) |
x |
x
|
'output_layer' (DLLayerRoIPooling) |
x
|
|
| 'shape' | x
|
|
'roi_pooling_type' (Type) |
x |
x
|
| 'type' | x
|
| Generische Layer-Parameter | set |
get
|
|---|---|---|
| 'enlarge_box_factor_long' | x |
x
|
| 'enlarge_box_factor_short' | x |
x
|
| 'fpn_roi_canonical_level' | x |
x
|
| 'fpn_roi_canonical_scale' | x |
x
|
| 'fpn_roi_max_level' | x
|
|
| 'fpn_roi_min_level' | x
|
|
| 'is_inference_output' | x |
x
|
| 'instance_type' | x
|
|
| 'mode' | x
|
|
| 'num_classes' | x
|
|
| 'num_trainable_params' | x
|
|
| 'sampling_ratio' | x |
x
|
| 'threshold_value' | x |
x
|
DLLayerInputImage (input_control) dl_layer → (handle)
Zuführender Layer, der das Eingabebild des Netzwerks enthält.
Default: 'InputImageLayer'
DLLayerRoI (input_control) dl_layer → (handle)
Zuführender Layer, der ROI-Koordinaten enthält.
Default: 'RoILayer'
DLLayerFeature (input_control) dl_layer(-array) → (handle)
Zuführende Layer, die die Merkmale/Ground-Truth-Instanzmasken enthalten von denen gepoolt wird.
Default: 'FeatureLayers'
DLLayerInstanceIndex (input_control) dl_layer → (handle)
Zuführender Layer, der abgestimmte Instanzindizes für jede ROI enthält.
Default: 'InstanceIndexLayer'
LayerName (input_control) string → (string)
Name des Ausgabelayers.
Type (input_control) string → (string)
Art des ROI-Poolings.
Default: 'roi_pool'
Werteliste: 'roi_align', 'roi_pool'
GridSize (input_control) number-array → (integer)
Dimensionen des Pooling-Gitters, Ausgabedimensionen.
Default: [7,7]
GenParamName (input_control) attribute.name(-array) → (string)
Namen der generischen Eingabeparameter.
Default: []
Werteliste: 'enlarge_box_factor_long', 'enlarge_box_factor_short', 'fpn_roi_canonical_level', 'fpn_roi_canonical_scale', 'instance_type', 'is_inference_output', 'mode', 'num_classes', 'sampling_ratio', 'threshold_value'
GenParamValue (input_control) attribute.value(-array) → (string / integer / real)
Werte der generischen Eingabeparameter.
Default: []
Wertevorschläge: 'feature', 'mask_target', 'rectangle1', 'rectangle2', 'true', 'false', 0.5
DLLayerRoIPooling (output_control) dl_layer → (handle)
ROI-Pooling-Layer.
* Example for create_dl_layer_roi_pooling.
* This model can be trained to classify multiple
* predefined RoIs in an image.
*
* Create simple model.
create_dl_layer_input ('image', [224,224,3], [], [], DLGraphNodeInput)
create_dl_layer_input ('gt_boxes', [1, 5, 5], [], [], DLGraphNodeGTBoxes)
create_dl_layer_input ('rois', [1, 6, 5], [], [], DLGraphNodeRoIs)
*
* Apply two convolution layer to extract features of the image.
create_dl_layer_convolution (DLGraphNodeInput, 'conv1', 3, 1, 2, 32, 1, \
'half_kernel_size', 'relu', [], [], \
DLGraphNodeConvolution)
create_dl_layer_convolution (DLGraphNodeConvolution, 'conv2', 3, 1, 2, 32, \
1, 'half_kernel_size', 'relu', [], [], \
DLGraphNodeConvolution2)
*
* Apply RoI pooling to pool the features for each RoI.
GridSize := [7,7]
create_dl_layer_roi_pooling (DLGraphNodeInput, DLGraphNodeRoIs, \
DLGraphNodeConvolution2, [], 'roi_pool', \
'roi_pool', GridSize, [], [], \
DLGraphNodeRoIPooling)
*
* Classify the RoIs according to the pooled features.
NumClasses := 3
create_dl_layer_dense (DLGraphNodeRoIPooling, 'fc1', 64, [], [], \
DLGraphNodeDense)
create_dl_layer_activation (DLGraphNodeDense, 'relu1', 'relu', [], \
[], Relu1)
create_dl_layer_dense (Relu1, 'cls_score', NumClasses + 1, [], [], \
DLGraphNodeScore)
create_dl_layer_softmax (DLGraphNodeScore, 'cls_prob', [], [], \
DLGraphNodeSoftMax)
*
* Append a cross entropy loss to train the classifier.
TargetOutputModes := ['cls_target', 'cls_weight']
TargetOutputNames := TargetOutputModes
create_dl_layer_box_targets (DLGraphNodeRoIs, DLGraphNodeGTBoxes, [], \
TargetOutputNames, 'box_proposals', \
TargetOutputModes, NumClasses, [], [], \
DLGraphNodeClsTarget, DLGraphNodeClsWeight, \
_, _, _, _, _)
create_dl_layer_loss_cross_entropy (DLGraphNodeSoftMax, \
DLGraphNodeClsTarget, \
DLGraphNodeClsWeight, 'cls_loss', \
1.0, [], [], \
DLGraphNodeLossCrossEntropy)
*
* Append a box proposal layer to get a detection-like output.
GenParamNameBoxProposal := ['input_mode', 'apply_box_regression', \
'max_overlap', 'max_overlap_class_agnostic']
GenParamValueBoxProposal := ['dense', 'false', 1.0, 1.0]
create_dl_layer_box_proposals (DLGraphNodeSoftMax, [], DLGraphNodeRoIs, \
DLGraphNodeInput, 'box_output', \
GenParamNameBoxProposal, \
GenParamValueBoxProposal, \
DLGraphNodeGenerateBoxProposals)
*
* Create the model.
create_dl_model ([DLGraphNodeLossCrossEntropy, \
DLGraphNodeGenerateBoxProposals], \
DLModelHandle)
set_dl_model_param (DLModelHandle, 'type', 'detection')
ClassIDs := [1:NumClasses]
set_dl_model_param (DLModelHandle, 'class_ids', ClassIDs)
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.
Deep Learning Professional