get_dl_model_param — Auslesen der Parameter des Deep Learning-Modells.
get_dl_model_param( : : DLModelHandle, GenParamName : GenParamValue)
get_dl_model_param gibt die Parameterwerte von
GenParamName für das Deep Learning-Modell DLModelHandle
in GenParamValue aus.
Für ein Deep Learning-Modell können die Parameter GenParamName, je
nach Parameter und Modelltyp, mit Hilfe von set_dl_model_param oder
create_dl_model_detection gesetzt werden.
Mit diesem Operator, get_dl_model_param, können die Parameterwerte
GenParamValue abgefragt werden.
Nachstehend ist ein Überblick über die verschiedenen Parameter für die
jeweiligen Modelltypen gegeben sowie eine Erklärung zu den Parametern,
mit Ausnahme jener, die nur gesetzt werden können.
Für eine Erklärung letztgenannter Parameter wird auf die Dokumentation der
entsprechenden Operatoren verwiesen.
Die Parameter sind entsprechend den Deep-Learning-Modellmethoden aufgeführt.
Um zu markieren, welche Operatoren für die Methoden verfügbar sind, verwenden wir folgende Notation:
set: Der Parameter kann mit set_dl_model_param
gesetzt werden.
get: Der Parameter kann mit get_dl_model_param
abgefragt werden.
create: Der Parameter kann mit create_dl_model_detection
gesetzt werden.
Gewisse Parameter werden als nicht-optionale Parameter gesetzt, die entsprechende Repräsentation ist in Klammern angegeben.
GenParamName |
set |
get
|
| 'batch_size' | x |
x
|
| 'device' | x |
x
|
| 'gpu' | x |
x
|
| 'image_dimensions' | x |
x
|
| 'image_height', 'image_width' | x |
x
|
| 'image_num_channels' | x
|
|
| 'meta_data' | x |
x
|
| 'optimize_for_inference' | x |
x
|
| 'precision' | x
|
|
| 'precision_is_converted' | x
|
|
| 'runtime' | x |
x
|
| 'runtime_init' | x |
|
| 'type' | x
|
GenParamName |
set |
get
|
| 'batch_size' | x |
x
|
| 'batchnorm_momentum' | x |
|
| 'complexity' | x |
x
|
| 'device' | x |
x
|
| 'enable_resizing' | x |
|
| 'fuse_bn_relu' | x |
|
| 'fuse_conv_relu' | x |
|
| 'gpu' | x |
x
|
| 'image_dimensions' | x |
x
|
| 'image_height', 'image_width' | x |
x
|
| 'image_num_channels' | x
|
|
| 'image_range_max', 'image_range_min' | x
|
|
| 'input_dimensions' | x |
x
|
| 'meta_data' | x |
x
|
| 'num_trainable_params' | x
|
|
| 'precision' | x
|
|
| 'precision_is_converted' | x
|
|
| 'runtime' | x |
x
|
| 'runtime_init' | x |
|
| 'standard_deviation_factor' | x |
x
|
| 'type' | x
|
GenParamName |
set |
get
|
| 'adam_beta1' | x |
x
|
| 'adam_beta2' | x |
x
|
| 'adam_epsilon' | x |
x
|
| 'batch_size' | x |
x
|
| 'batch_size_multiplier' | x |
x
|
| 'batchnorm_momentum' | x |
|
| 'class_ids' | x
|
|
| 'class_names' | x |
x
|
| 'class_weights' | x |
x
|
| 'device' | x |
x
|
| 'enable_resizing' | x |
|
| 'extract_feature_maps' | x |
x
|
| 'fuse_bn_relu' | x |
|
| 'fuse_conv_relu' | x |
|
| 'gpu' | x |
x
|
| 'image_dimensions' | x |
x
|
| 'image_height', 'image_width' | x |
x
|
| 'image_num_channels' | x |
x
|
| 'image_range_max', 'image_range_min' | x
|
|
| 'input_dimensions' | x |
x
|
| 'layer_names' | x
|
|
| 'learning_rate' | x |
x
|
| 'meta_data' | x |
x
|
| 'momentum' | x |
x
|
| 'num_trainable_params' | x
|
|
| 'optimize_for_inference' | x |
x
|
| 'precision' | x
|
|
| 'precision_is_converted' | x
|
|
| 'runtime' | x |
x
|
| 'runtime_init' | x |
|
| 'solver_type' | x |
x
|
| 'summary' | x
|
|
| 'type' | x
|
|
| 'weight_prior' | x |
x
|
GenParamName |
set |
get
|
| 'adam_beta1' | x |
x
|
| 'adam_beta2' | x |
x
|
| 'adam_epsilon' | x |
x
|
| 'alphabet' | x |
x
|
| 'alphabet_internal' | x |
x
|
| 'alphabet_mapping' | x |
x
|
| 'batch_size' | x |
x
|
| 'batchnorm_momentum' | x |
|
| 'device' | x |
x
|
| 'enable_resizing' | x |
|
| 'fuse_bn_relu' | x |
|
| 'fuse_conv_relu' | x |
|
| 'gpu' | x |
x
|
| 'image_dimensions' | x |
x
|
| 'image_height', 'image_width' | x |
x
|
| 'image_num_channels' | x |
x
|
| 'image_range_max', 'image_range_min' | x |
x
|
| 'input_dimensions' | x |
x
|
| 'layer_names' | x
|
|
| 'learning_rate' | x |
x
|
| 'meta_data' | x |
x
|
| 'momentum' | x |
x
|
| 'num_trainable_params' | x
|
|
| 'optimize_for_inference' | x |
x
|
| 'precision' | x
|
|
| 'precision_is_converted' | x
|
|
| 'runtime' | x |
x
|
| 'runtime_init' | x |
|
| 'solver_type' | x |
x
|
| 'summary' | x
|
|
| 'type' | x
|
|
| 'weight_prior' | x |
x
|
GenParamName |
set |
get
|
| 'adam_beta1' | x |
x
|
| 'adam_beta2' | x |
x
|
| 'adam_epsilon' | x |
x
|
| 'anomaly_score_tolerance' | x |
x
|
| 'batch_size' | x |
x
|
| 'batch_size_multiplier' | x |
x
|
| 'batchnorm_momentum' | x |
|
| 'device' | x |
x
|
| 'enable_resizing' | x |
|
| 'fuse_bn_relu' | x |
|
| 'fuse_conv_relu' | x |
|
| 'gc_anomaly_networks' | x |
x
|
| 'gpu' | x |
x
|
| 'image_dimensions' | x |
x
|
| 'image_height', 'image_width' | x |
x
|
| 'image_num_channels' | x |
x
|
| 'image_range_max', 'image_range_min' | x
|
|
| 'input_dimensions' | x
|
|
| 'layer_names' | x
|
|
| 'learning_rate' | x |
x
|
| 'meta_data' | x |
x
|
| 'momentum' | x |
x
|
| 'num_trainable_params' | x
|
|
| 'optimize_for_inference' | x |
x
|
| 'patch_size' | x |
x
|
| 'precision' | x
|
|
| 'precision_is_converted' | x
|
|
| 'runtime' | x |
x
|
| 'runtime_init' | x |
|
| 'solver_type' | x |
x
|
| 'summary' | x
|
|
| 'type' | x
|
|
| 'weight_prior' | x |
x
|
GenParamName |
set |
get |
create
|
| 'adam_beta1' | x |
x |
|
| 'adam_beta2' | x |
x |
|
| 'adam_epsilon' | x |
x |
|
| 'anchor_angles' | x |
x
|
|
| 'anchor_aspect_ratios' | x |
x
|
|
| 'anchor_num_subscales' | x |
x
|
|
'backbone' (Backbone) |
x |
x
|
|
| 'backbone_docking_layers' | x |
x |
x
|
| 'batch_size' | x |
x |
|
| 'batch_size_multiplier' | x |
x |
|
| 'batchnorm_momentum' | x |
||
| 'bbox_heads_weight', 'class_heads_weight' | x |
x |
x
|
| 'capacity' | x |
x
|
|
| 'class_ids' | x |
x |
x
|
| 'class_ids_no_orientation' | x |
x
|
|
| 'class_names' | x |
x |
x
|
| 'class_weights' | x |
||
| 'device' | x |
x |
|
| 'enable_resizing' | x |
||
| 'freeze_backbone_level' | x |
x |
x
|
| 'fuse_bn_relu' | x |
||
| 'fuse_conv_relu' | x |
||
| 'gpu' | x |
x |
|
| 'ignore_direction' | x |
x
|
|
| 'image_dimensions' | x |
x
|
|
| 'image_height', 'image_width' | x |
x
|
|
| 'image_num_channels' | x |
x
|
|
| 'image_range_max', 'image_range_min' | x |
||
| 'input_dimensions' | x |
||
| 'instance_segmentation' | x |
x
|
|
| 'instance_type' | x |
x
|
|
| 'layer_names' | x |
||
| 'learning_rate' | x |
x |
|
| 'mask_head_weight' | x |
x |
x
|
| 'max_level', 'min_level' | x |
x
|
|
| 'max_num_detections' | x |
x |
x
|
| 'max_overlap' | x |
x |
x
|
| 'max_overlap_class_agnostic' | x |
x |
x
|
| 'meta_data' | x |
x |
|
| 'min_confidence' | x |
x |
x
|
| 'momentum' | x |
x |
|
'num_classes' (NumClasses) |
x |
x
|
|
| 'num_trainable_params' | x |
||
| 'optimize_for_inference' | x |
x |
x
|
| 'precision' | x |
||
| 'precision_is_converted' | x |
||
| 'runtime' | x |
x |
|
| 'runtime_init' | x |
||
| 'solver_type' | x |
x |
|
| 'summary' | x |
||
| 'type' | x |
||
| 'weight_prior' | x |
x |
GenParamName |
set |
get
|
| 'adam_beta1' | x |
x
|
| 'adam_beta2' | x |
x
|
| 'adam_epsilon' | x |
x
|
| 'batch_size' | x |
x
|
| 'batch_size_multiplier' | x |
x
|
| 'batchnorm_momentum' | x |
|
| 'class_ids' | x |
x
|
| 'class_names' | x |
x
|
| 'device' | x |
x
|
| 'enable_resizing' | x |
|
| 'fuse_bn_relu' | x |
|
| 'fuse_conv_relu' | x |
|
| 'gpu' | x |
x
|
| 'ignore_class_ids' | x |
x
|
| 'image_dimensions' | x |
x
|
| 'image_height', 'image_width' | x |
x
|
| 'image_num_channels' | x |
x
|
| 'image_range_max', 'image_range_min' | x |
x
|
| 'input_dimensions' | x |
x
|
| 'layer_names' | x
|
|
| 'learning_rate' | x |
x
|
| 'meta_data' | x |
x
|
| 'momentum' | x |
x
|
| 'num_classes' | x
|
|
| 'num_trainable_params' | x
|
|
| 'optimize_for_inference' | x |
x
|
| 'precision' | x
|
|
| 'precision_is_converted' | x
|
|
| 'runtime' | x |
x
|
| 'runtime_init' | x |
|
| 'solver_type' | x |
x
|
| 'summary' | x
|
|
| 'type' | x
|
|
| 'weight_prior' | x |
x
|
Im Folgenden werden die Parameter GenParamName, deren Werte mit
get_dl_model_param abgefragt werden können, aufgelistet und
erläutert.
Dabei bezeichnen die folgenden Symbole den Modelltypen, für welchen der
Parameter bekommen werden kann.
'Any': Jede Methode
'3D-GPD': 'type'='3d_gripping_point_detection'
'AD': 'type'='anomaly_detection'
'CL': 'type'='classification'
'DO': 'type'='ocr_recognition'
'GC-AD': 'type'='gc_anomaly_detection'
'OD': 'type'='detection'
'SE': 'type'='segmentation'
'Gen': 'type'='generic'
Dieser Wert definiert das Moment für den linearen Term des
Adam Solvers. Für mehr Informationen wird auf die
Dokumentation von train_dl_model_batch verwiesen.
Restriktion: Nur verfügbar wenn 'solver_type' = 'adam'.
Default: 'adam_beta1' = 0.9
Dieser Wert definiert das Moment für den quadratischen Term des
Adam Solvers. Für mehr Informationen wird auf die
Dokumentation von train_dl_model_batch verwiesen.
Restriktion: Nur verfügbar wenn 'solver_type' = 'adam'.
Default: 'adam_beta2' = 0.999
Dieser Wert definiert das Epsilon in der Adam Solver Formel und
ist für die numerische Stabilität verantwortlich.
Für mehr Informationen wird auf die
Dokumentation von train_dl_model_batch verwiesen.
Restriktion: Nur verfügbar wenn 'solver_type' = 'adam'.
Default: 'adam_epsilon' = 1e-08
Der Zeichensatz, welchen das Modell erkennen kann.
Dieser Zeichensatz enthält alle Zeichen die kein Mapping auf das erste Zeichen des internen Alphabets haben (siehe Parameter 'alphabet_mapping' und 'alphabet_internal')).
Das Alphabet kann bei Bedarf geändert oder erweitert werden. Wird das
Alphabet über 'alphabet' geändert, so werden das
interne Alphabet und dessen Mapping so geändert, dass, falls möglich,
die Länge des internen Alphabets gleich bleibt.
Es wird empfohlen das Modell mit anwendungsspezifischen Daten
nachzutrainieren wenn das Alphabet geändert wird (siehe auch das
HDevelop Beispielprogramm
deep_ocr_recognition_training_workflow.hdev). Für zuvor
unbekannte Zeichen werden mehr Trainingsdaten benötigt.
Es ist zu beachten, dass, falls sich die Länge des internen Alphabets ändert, die letzten Modell-Layer zufällig initialisiert werden müssen und dadurch zufällige Strings als Ausgabe resultieren (siehe 'alphabet_internal'). In diesem Fall ist es zwingend notwendig das Modell nachzutrainieren.
Der vollständige Zeichensatz mit dem die Deep OCR Erkennungs-Komponente trainiert wurde.
Das erste Zeichen des internen Alphabets hat eine Sonderstellung. Im vortrainierten Modell ist es als leeres Braillezeichen (U+2800) spezifiziert, ist dabei aber nicht mit dem Leerzeichen zu verwechseln. Dieses leeres Braillezeichen wird nie in einem Wort zurückgegeben, kann dafür aber als Kandidat für Zeichen zurückgegeben werden. Das leeres Braillezeichen ist notwendig und muss auch bei einer Änderung des internen Alphabets das erste Zeichen des Alphabets bleiben. Das leeres Braillezeichen wird automatisch zum Zeichensatz hinzugefügt falls das Alphabet mit 'alphabet' geändert wird.
Die Länge dieses Tupels entspricht der Tiefe des letzten
Faltungs-Layers des Modells. Ändert sich die Länge, dann müssen
die Größen des letzten Faltungslayers und aller folgenden Layer
angepasst und möglicherweise zufällig reinitialisiert werden.
Nach einer entsprechenden Änderung ist es notwendig das Modell
nachzutrainieren (siehe HDevelop Beispielprogramm
deep_ocr_recognition_training_workflow.hdev).
Es wird empfohlen den Parameter 'alphabet' zur Änderung des Alphabets zu verwenden, da dadurch versucht wird die Länge des internen Alphabets automatisch zu erhalten.
Tupel mit ganzzahligen Indizes.
Es handelt sich um ein Mapping, das vom Modell während der Dekodierung jedes Wortes angewendet wird. Das Mapping überschreibt jedes Zeichen von 'alphabet_internal' mit dem vom Index festgelegten Zeichen aus 'alphabet_internal'.
Das über die Indizes des Tupels definierte Mapping wird im Dekodierungsschritt auf die vorhergesagten Zeichen angewandt. Das Tupel muss dieselbe Länge wie das Tupel 'alphabet_internal' haben. Jeder der ganzzahligen Indizes von 'alphabet_mapping' muss zwischen 0 |'alphabet_internal'|-1 liegen.
Manchmal kann es nützlich sein ein Mapping für bestimmte Zeichen aufeinander zu definieren. Falls beispielsweise nur Zahlen in einer Anwendung auftreten können kann es sinnvoll sein ein Mapping des Zeichens "O" auf "0" festzulegen. Das Modell muss dafür nicht nachtrainiert werden.
Falls ein Eintrag auf 0 gesetzt wird, wird das entsprechende Zeichen in 'alphabet_internal' in keinem Wort dekodiert.
Der Parameter 'anchor_angles' bestimmt den
Orientierungswinkel der Anchors eines Modells mit
'instance_type' = 'rectangle2'.
Dabei ist die Orientierung in Bogenmaß angegeben und gibt den Winkel
zwischen der horizontalen Achse und Length1 an
(mathematisch positiv).
Für weitere Informationen zu Anchors siehe das
Kapitel Deep Learning / Objektdetektion und Instanz-Segmentierung.
Es kann ein Tupel mit Werten gesetzt werden. Eine höhere Anzahl an Winkel erhöht die Anzahl vorgeschlagener umschließender Rechtecke, was zu einer besseren Lokalisierung führen kann, allerdings auch mehr Laufzeit und Speicherplatz in Anspruch nimmt.
Mögliche Werte: 'anchor_angles' für 'ignore_direction' = 'false', 'anchor_angles' für 'ignore_direction' = 'true'
Default: 'anchor_angles' = [0.0]
Der Parameter 'anchor_aspect_ratios' bestimmt das Seitenverhältnis des umschließenden Referenzrechtecks. Dabei bestimmt der Instanztyp 'instance_type', wie dieses Verhältnis definiert ist:
'rectangle1': Verhältnis von Höhe zu Breite
'rectangle2': Verhältnis von Length1 zu
Length2
So ergibt z.B. für Instanztyp 'rectangle1' ein Wert von 2 ein schmales initiales Referenzrechteck, während 0.5 ein breites Referenzrechteck ergibt.
Die Größe des generierten umschließenden Rechtecks wird durch den Parameter 'anchor_num_subscales' beeinflusst und mit seiner Erklärung findet sich auch die genaue Formel für die Größen und die Längen der resultierenden umschließenden Anchors. Für weitere Informationen zu umschließenden Rechtecken siehe das Kapitel Deep Learning / Objektdetektion und Instanz-Segmentierung.
Es kann ein Tupel mit Werten gesetzt werden. Eine höhere Anzahl an Seitenverhältnissen erhöht die Anzahl vorgeschlagener umschließender Rechtecke, was zu einer besseren Lokalisierung führen kann, allerdings auch mehr Laufzeit und Speicherplatz in Anspruch nimmt.
Aus Gründen der Rückwärtskompatibilität kann anstelle des Parameters 'anchor_aspect_ratios' auch der Parameter 'aspect_ratios' verwendet werden.
Default: 'anchor_aspect_ratios' = [1.0, 2.0, 0.5]
Dieser Parameter bestimmt die Anzahl an Anchors, die für jedes angegebenen Größenverhältnis in verschiedenen Skalierungen generiert werden.
In HALCON werden für jedes Pixel jeder Merkmalskarte der Merkmalspyramide umschließende Rechtecke vorgeschlagen. Der Parameter 'anchor_aspect_ratios' beeinflusst die Form, der Parameter 'anchor_num_subscales' die Größe. So werden auf jedem oben erwähnten Pixel 'anchor_aspect_ratios' mal 'anchor_num_subscales' umschließende Rechtecke generiert. Für weitere Informationen zu umschließenden Rechtecken siehe das Kapitel Deep Learning / Objektdetektion und Instanz-Segmentierung. Ein Beispiel findet sich in unten stehender Darstellung.
Ein umschließendes Referenzrechteck der Ebene hat auf dem Eingabebild standardmäßige Kantenlängen von , wobei der Parameter den Wert Pixel hat. Mit dem Parameter 'anchor_num_subscales' können zusätzliche umschließende Rechtecke generiert werden, die größenmäßig zur Größe des kleinsten umschließenden Referenzrechtecks der Ebene konvergiert. Genauer haben diese umschließenden Referenzrechtecke der Ebene auf dem Eingabebild die Kantenlängen wobei . Dies ergibt auf der Ebene für subscale ein umschließendes Referenzrechteck mit Höhe und Breite von wobei das Seitenverhältnis dieses umschließenden Referenzrechtecks ist (siehe 'anchor_aspect_ratios'.
Eine große Anzahl von Subskalierungen erhöht die Anzahl vorgeschlagener umschließender Rechtecke und nimmt daher auch mehr Laufzeit und Speicherplatz in Anspruch.
Aus Gründen der Rückwärtskompatibilität kann anstelle des Parameters 'anchor_num_subscales' auch der Parameter 'num_subscales' verwendet werden.
Default: 'anchor_num_subscales' = 3
Der Anomalie-Score auf Bildebene wird intern so bestimmt, dass
ein gewisser Bruchteil an Pixel Anomalie-Scores in anomaly_image
größer oder gleich groß ist wie der Wert des Anomalie-Score.
Dieser Bruchteil kann über 'anomaly_score_tolerance' gesetzt
werden, wobei der Wert im Intervall [0.0, 1.0] liegen muss.
Wird der Wert von 'anomaly_score_tolerance' beispielsweise auf
0.01 gesetzt, so liegt 1 Prozent der Pixelwerte in
anomaly_image über dem berechneten Anomalie-Score.
'anomaly_score_tolerance' kann daher verwendet werden um
Ausreißer in anomaly_image zu unterdrücken.
Default: 'anomaly_score_tolerance' = 0.0
Der Parameter 'backbone' ist der Name (inklusive Pfad) des
Backbone-Netzwerks, das zum Erstellen des Modells verwendet wird. Eine
Liste der verschiedenen mitgelieferten Backbone-Netzwerke ist unter
create_dl_model_detection zu finden.
Der Parameter 'backbone_docking_layers' spezifiziert, welche Layer des Backbones von der Merkmalspyramide als Docking Layer verwendet werden sollen. Dabei werden die Layer über ihre Namen referenziert.
Die Spezifikation der Docking Layer kann bei jedem Klassifikator erfolgen, auch ohne dass diese als Backbone eingelesen werden. Berücksichtigt wird diese Angabe jedoch nur für Backbones der Objektdetektion. Beim Auswählen der Docking Layer muss beachtet werden, dass die Längen der Merkmalskarten von einem Docking Layer zum nächsten jeweils halbiert werden. Daumenregel: Jeweils der tiefste Layer für jede (seitliche) Auflösung im Backbone (entspricht einer Ebene, welche für die spezifische Objektdetektions-Aufgabe notwendigen ist).
Informationen zu den Namen und Größen der Layer eines Modells können mittels 'summary' abgefragt werden.
Default: Für die vortrainierten Backbones die von HALCON ausgeliefert werden, hängen die Standardwerte vom Klassifikator ab. Andere Klassifikatoren haben keine standardmäßig gesetzten Docking Layer, weshalb dieser Parameter gesetzt werden muss, bevor sie als Backbone verwendet werden können.
Anzahl der Bilder (und ihren entsprechenden Labels) in einem Batch, die gleichzeitig in den Gerätespeicher transferiert werden.
Bei einem Training mittels train_dl_model_batch ist die Menge
der Bilder, die in einer Iteration miteinander
verarbeitet werden, beinhaltet eine Anzahl 'batch_size' mal
'batch_size_multiplier' Bilder. Für weitere Details siehe
train_dl_model_batch.
Bei der Inferenz kann die 'batch_size' im Allgemeinen
unabhängig von der Anzahl der gleichzeitig zu inferierenden Bilder
gesetzt werden. Siehe apply_dl_model für weitere Informationen,
wie man diesen Parameter setzt, um eine größere Effizienz zu erzielen.
Der Parameter 'batch_size' ist im vortrainierten Modell
gespeichert. Standardmäßig ist 'batch_size' so gesetzt,
dass ein Training des vortrainierten Klassifikators mit bis zu
100 Klassen problemlos auf einer GPU mit einem Speicher
von 8 Gigabyte durchgeführt werden kann.
| Vortrainierter Klassifikator | Standardwerte für 'batch_size' |
|---|---|
| 'pretrained_dl_classifier_alexnet.hdl' | 230 |
| 'pretrained_dl_classifier_compact.hdl' | 160 |
| 'pretrained_dl_classifier_enhanced.hdl' | 96 |
| 'pretrained_dl_classifier_mobilenet_v2.hdl' | 40 |
| 'pretrained_dl_classifier_resnet18.hdl' | 24 |
| 'pretrained_dl_classifier_resnet50.hdl' | 23 |
Multiplikationsfaktor für 'batch_size', um das Training mit
einer größeren Anzahl an Bildern in einem Schritt zu ermöglichen, was
aufgrund limitierter GPU-Speichergröße sonst nicht möglich wäre.
Dieser Parameter beeinflusst nur das Training mit
train_dl_model_batch und hat somit weder auf die Evaluierung
noch auf die Inferenz einen Einfluss.
Für weitere Details, siehe train_dl_model_batch.
Der Parameter 'batch_size_multiplier' hat keinen Einfluss.
Der Parameter 'batch_size_multiplier' hat keinen Einfluss.
Default: 'batch_size_multiplier' = 1
Die Parameter 'bbox_heads_weight' und 'class_heads_weight' sind Gewichtungsfaktoren bei der Bestimmung der Gesamt-Zielfunktion. Dies bedeutet, dass beim Aufsummieren der einzelnen Zielfunktionswerte die Beiträge der Heads zur Bestimmung der umschließenden Rechtecke mit dem Faktor 'bbox_heads_weight' und die Beiträge der Heads zur Klassifikation mit dem Faktor 'class_heads_weight' gewichtet werden.
Default: 'bbox_heads_weight' = 1.0, 'class_heads_weight' = 1.0
Bestimmt die Anzahl der Parameter (oder Filtergewichte) in den tieferen Teilen des Netzwerkes zur Objektdetektion (d.h., nach dem Backbone). Mögliche Werte sind 'high', 'medium' und 'low'.
Er kann verwendet werden, um zwischen Detektionsleistung und Geschwindigkeit abzuwägen. Für einfachere Objektdetektionsaufgaben können die Einstellungen 'low' oder 'medium' ausreichen, um ähnliche Detektionsleistung wie mit 'high' zu erzielen.
Default: 'capacity' = 'high'
Eindeutige IDs der Klassen, die vom Modell unterschieden werden sollen. Daher hat das Tupel die Länge von 'num_classes'.
Hierbei sollen die leicht unterschiedlichen Bedeutungen und Beschränkungen in Abhängigkeit des Modelltyps betont werden:
Die IDs sind eindeutige Bezeichner, die automatisch den Klassen zugeordnet werden. Dabei entsprechen die ID einer Klasse dem Index der Klasse im Tupel 'class_names'.
Beinhaltet nur die Klassen der zu erkennenden Objekte, und somit keine Hintergrund-Klasse. Dabei kann als Klassen-ID ein beliebiger Integer-Wert aus dem Wertebereich gesetzt werden.
Es gilt zu beachten, dass die Werte in 'class_ids_no_orientation' von jenen in 'class_ids' abhängen. Falls die Werte in 'class_ids' nach der Erzeugung des Modells verändert werden, wird 'class_ids_no_orientation' auf ein leeres Tupel zurückgesetzt.
Default: 'class_ids' = '[0,...,num_classes-1]'
Jede zum Training genutzte Klasse muss enthalten sein und damit ebenfalls die Klassen-ID der Klasse 'background'. Daher hat für ein solches Modell das Tupel die die minimale Länge 2. Dabei kann als Klassen-ID ein beliebiger Integer-Wert aus dem Wertebereich gesetzt werden.
Mit diesem Parameter können Klassen angegeben werden, für welche die Orientierung nicht berücksichtigt wird, z.B. runde oder andere punktsymmetrische Objekte. Für jede Klasse, deren Klassen-ID in 'class_ids_no_orientation' präsent ist, gibt das Netzwerk ein achsenparalleles umschließendes Rechteck zurück.
Dieser Parameter betrifft nur Netzwerke mit 'instance_type' = 'rectangle2'.
Es gilt zu beachten, dass die Werte in 'class_ids_no_orientation' von jenen in 'class_ids' abhängen. Falls die Werte in 'class_ids' nach der Erzeugung des Modells verändert werden, wird 'class_ids_no_orientation' auf ein leeres Tupel zurückgesetzt.
Default: 'class_ids_no_orientation' = []
Eindeutige Namen der vom Modell zu unterscheidenden Klassen. Die Anordnung der Klassennamen bleibt nach dem Setzen unverändert. Das Tupel hat die Länge 'num_classes'.
Der Parameter 'class_weights' ist ein Tupel klassenspezifischer Gewichtungsfaktoren für die Zielfunktion. Erhalten die verschiedenen Klassen unterschiedliche Gewichte, so wird das Netzwerk forciert, den Klassen beim Lernen eine unterschiedliche Bedeutung zu geben. Dies ist nützlich, wenn eine Klasse den Datensatz dominiert. Die einzelnen Gewichtungsfaktoren müssen innerhalb des Intervalls sein. Dabei gilt, je größer das Gewicht einer Klasse, desto stärker ist ihr Einfluss beim Training. Im Tupel 'class_weights' sind die Faktoren gleich angeordnet wie die Klassen im Tupel 'class_ids'. Je nach Modelltyp sind folgende Unterschiede zu beachten:
Default: 'class_weights' = 1.0 für jede Klasse.
Default: 'class_weights' = 0.25 für jede Klasse.
Dieser Parameter steuert die Kapazität des Modells, komplexere Anwendungen zu lösen. Ein höherer Wert ermöglicht es dem Modell, Bilder mit größerer Komplexität darstellen zu können. Allerdings steigen dann auch die Laufzeiten von Training und Inferenz. Dieser Parameter kann nur vor dem Training des Modells gesetzt werden, da ansonsten das Modell in einen unbrauchbaren Zustand versetzt würde. Falls versucht wird, 'complexity' in einem bereits trainierten Modell zu setzen, wird ein Fehler ausgegeben und das Modell bleibt unverändert.
Default: 'complexity' = 15
Handle der Hardware-Einheit, auf der die Deep Learning Operatoren ausgeführt werden.
Falls das Modell bereits für eine Hardware-Einheit optimiert wurde,
ist das Setzen von 'device' in manchen Fällen nicht mehr zusätzlich
notwendig, siehe optimize_dl_model_for_inference für Details dazu.
Ein Tupel aller Handles aller potentiell Deep Learning fähigen Geräte kann
über query_available_dl_devices erzeugt werden.
Default: Handle der standardmäßig gesetzten GPU mit Index 0 in der mit 'gpu' erhaltenen Liste. Falls keine GPU vorhanden ist, ein leeres Tupel.
Mit diesem Parameterwert kann man die Merkmalskarten des angegebenen Modell-Layers für ein inferiertes Bild extrahieren.
Der ausgewählte Layer muss Bestandteil des vorhandenen
Netzwerks sein. Eine Übersicht aller vorhandenen Layer des Modells
kann durch den Operator get_dl_model_param mit dem zugehörigen
Parameter 'summary' zurückgegeben werden.
Beachte, die Netzwerkarchitektur wird durch diese Option verändert:
Das Netzwerk wird nach dem ausgewählten Layer
abgeschnitten. Dies kann nicht rückgängig gemacht werden.
Soll die originale Netzwerkarchitektur wieder verwendet werden,
muss diese mit read_dl_model erneut eingelesen werden.
Dieser Parameter bestimmt die Backbone Levels deren Gewichte während des Trainings unverändert bleiben (also nicht aktualisiert werden und somit eingefroren sind). Dabei bestimmt die gesetzte Zahl den höchsten Level, dessen Layer unverändert bleiben. Setzt man 'freeze_backbone_level' auf 0, so sind die Layer keines Levels eingefroren, es werden die Gewichte aller Layer aktualisiert. Dies wird empfohlen, falls die Gewichte zufällig initialisiert wurden (was z.B. nach gewissen Wechsel der Anzahl Bildkanäle passieren kann) oder im Falle eines nicht vortrainierten Backbones.
Default: 'freeze_backbone_level' = 2
Mit diesem Parameter können Subnetzwerke des Modells ausgewählt werden. Es können folgende Werte gesetzt werden:
'local': Das lokale Subnetzwerk wird extrahiert.
'global': Das globale Subnetzwerk wird extrahiert.
Für weitere Informationen zu den Subnetzwerken und ihren Eigenschaften siehe Deep Learning / Anomalieerkennung und Global Context Anomaly Detection.
Beachte, die Modellarchitektur wird durch diese Option verändert:
Das Originialmodell beinhaltet das lokale und das globale Subnetzwerk.
Nach dem Setzen eines Subnetzwerks wird das Modell abgeschnitten. Dies
kann nicht rückgängig gemacht werden.
Soll die originale Modellarchitektur wieder verwendet werden,
muss das Modell mit read_dl_model erneut eingelesen werden.
Default: 'gc_anomaly_networks' = ['local', 'global']
Identifikationsnummer der GPU, auf der die Trainings- und
Inferenz-Operatoren (train_dl_model_batch und
apply_dl_model) ausgeführt werden.
Standardmäßig wird die erste verfügbare GPU verwendet.
Mit dem get_system Parameter
'cuda_devices' kann die Liste der verfügbaren GPUs abgefragt
werden. In 'gpu' muss der Index der gewünschten GPU in dieser
Liste übergeben werden.
Es ist zu beachten, dass der Wert für 'gpu' nur berücksichtig wird, falls 'runtime'='gpu' gesetzt ist. Deshalb sollte das Setzen der spezifischen GPU vorzugsweise über den Parameter 'device' erfolgen.
Default: 'gpu' = 0
Mit diesem Parameter können eine oder mehrere Klassen auf 'ignore' gesetzt werden. Für weitere Informationen siehe Deep Learning / Semantische Segmentierung und Kantenextraktion. Diese Klassen werden über ihre ID (Integer-Wert) deklariert.
Zu beachten ist, dass eine Klassen-ID nicht gleichzeitig in 'ignore_class_ids' und 'class_ids' gesetzt werden kann.
Dieser Parameter bestimmt ob für das orientierte umschließende Rechteck auch die Ausrichtung des Objekts innerhalb des umschließenden Rechtecks berücksichtigt wird oder nicht. Falls die Ausrichtung innerhalb des umschließenden Rechtecks nicht berücksichtigt werden soll, kann 'ignore_direction' = 'true' gesetzt werden, Um das umschließende Rechteck eindeutig zu bestimmen, gelten dabei (aber nur dann) die folgende Konventionen:
'phi'
'bbox_length1' > 'bbox_length2'
Dies ist konsistent zu smallest_rectangle2.
Dieser Parameter betrifft nur Netzwerke mit 'instance_type' = 'rectangle2'.
Mögliche Werte: 'true', 'false'
Default: 'ignore_direction' = 'false'
Tupel, das die Dimensionen der Eingabebilder 'image_width', 'image_height' und Anzahl der Bildkanäle 'image_num_channels' beinhaltet.
Die jeweiligen Standardwerte und möglichen Wertebereiche sind vom Modelltyp und Modell selbst abhängig. Weitere Angaben dazu finden sich in der Beschreibung des jeweiligen Dimensionsparameters.
Höhe und Breite die die Eingabebilder aufweisen und mit denen das Netzwerk arbeitet.
Dieser Parameter kann abhängig vom Modelltyp verschiedene Werte annehmen:
Die Netzwerkarchitekturen erlauben Änderungen der Bildhöhe und -breite.
Der Standardwerte werden dabei vom Netzwerk vorgegeben,
siehe read_dl_model.
Die Standardwerte hängen von dem zu verwendenden Netzwerk ab,
siehe read_dl_model.
Die Netzwerkarchitekturen erlauben verschiedene Bildgrößen,
welche über set_dl_model_param gesetzt werden können.
Siehe auch read_dl_model um zu erfahren, welche Einschränkungen
es für die Eingabebildgröße bei den jeweiligen ausgelieferten Netzwerken
gibt.
Das Setzen der Bildgröße muss vor dem Training des Modells erfolgen,
da ansonsten das Modell in einen unbrauchbaren Zustand versetzt würde.
Falls versucht wird, die oben genannten Parameter in einem bereits
trainierten Modell zu setzen, wird ein Fehler ausgegeben und das Modell
bleibt unverändert.
Die Standardwerte hängen vom vortrainierten Klassifikator ab,
siehe read_dl_model.
Die Netzwerkarchitekturen erlauben verschiedene Bildgrößen,
welche über set_dl_model_param gesetzt werden können.
Für Netzwerke mit Fully-connected Layern wird dadurch ein
Nachtrainieren notwendig.
Netzwerke ohne Fully-connected Layer sind direkt auf verschiedenen
Bildgrößen anwendbar. Jedoch wird für Bilder, deren Größe von der
Bildgröße der Trainingsbilder abweicht, eine geringere Genauigkeit
bei der Klassifikation erwartet.
Die Netzwerkarchitekturen erlauben Änderungen der Bilddimensionen.
Jedoch werden für jede Ebene die Bildlängen halbiert, weshalb
'image_width' und 'image_height' ganzzahlige
Vielfache von
.
Dabei ist die Anzahl Ebenen vom Backbone und
dem Parameter 'max_level' abhängig, siehe
create_dl_model_detection.
Default: 'image_height' = 640, 'image_width' = 640
Die Netzwerkarchitektur erlaubt eine Änderung der Bilddimensionen. Das Setzen der Bildgröße muss vor dem Training des Modells erfolgen, da ansonsten das Modell in einen unbrauchbaren Zustand versetzt würde.
Restriktion: Die Werte von 'image_width' und 'image_height' müssen größer gleich der gesetzten 'patch_size' sein.
Default: 'image_height' = 256, 'image_width' = 256
Die Netzwerkarchitekturen erlauben Änderungen der Bildbreite.
Der Standardwert und Minimalwerte werden dabei vom Netzwerk
vorgegeben, siehe read_dl_model.
Die Netzwerkarchitekturen erlauben Änderungen der Bilddimensionen.
Der Standardwert und Minimalwerte werden dabei vom Netzwerk
vorgegeben, siehe read_dl_model.
Anzahl Kanäle der Eingabebilder, die vom Netzwerk verarbeitet werden.
Der Standardwert wird dabei vom Netzwerk vorgegeben, siehe
read_dl_model und create_dl_model_detection.
Für Modelle mit 'type'='anomaly_detection' oder 'type'='gc_anomaly_detection' werden nur die Werte 1 und 3 unterstützt. Außerdem sollte für diese Modelle der Parameter vor dem Training des Modells gesetzt werden. Für Modelle mit 'type'='anomaly_detection' würde das Modell ansonsten in einen unbrauchbaren Zustand versetzt. Falls versucht wird, 'image_num_channels' in einem bereits trainierten Modell zu setzen, wird für Modelle mit 'type'='anomaly_detection' daher ein Fehler ausgegeben und das Modell bleibt unverändert.
Für Deep OCR Lokalisierungs- und Erkennungs-Komponenten kann die Anzahl der Kanäle nur auf den jeweiligen Standardwert gesetzt werden (3 für 'type'='ocr_detection' und 1 für 'type'='ocr_recognition').
Für Modelle mit 'type'='3d_gripping_point_detection' darf die Anzahl der Kanäle nicht geändert werden.
Für andere Modelle ist eine beliebige Anzahl an Kanälen möglich.
Wird die Anzahl auf einen Wert >1 geändert, werden die Werte aller Layer nach dem Eingabelayer mit Zufallswerten initialisiert. In diesem Fall sind mehr Daten zum Nachtrainieren notwendig. Wird die Anzahl Kanäle der Eingabebilder auf 1 geändert, so werden die Gewichte der entsprechenden Layer vereinigt.
Default: 'image_num_channels' = 3
Default: 'image_num_channels' = 3
Maximaler und minimaler möglicher Grauwert der Eingabebilder, welche das Netzwerk verarbeitet.
Die Werte werden dabei vom Netzwerk vorgegeben,
siehe read_dl_model und create_dl_model_detection.
Dictionary, welches die Dimensionen aller Netzwerkeingaben beinhaltet.
Beispiele für solche Eingaben: Eingabebild, weight_image
(bei Modellen mit 'type'='segmentation').
Diese Dimensionen sind im Dictionary als Tupel
[Breite, Höhe, Tiefe] gegeben.
Verwendet man diesen Parameter zum Setzen der Werte, kann für
jede Dimension der Wert -1 gesetzt werden um den aktuellen Wert
beizubehalten.
Dieser Parameter bestimmt, ob ein Modell für
Instanz-Segmentierung erzeugt wurde.
Wenn der Parameter in create_dl_model_detection auf
'true' gesetzt wird, wird das Detektions-Deep Learning Netzwerk
mit zusätzlichen Layern für die Instanz-Segmentierung erweitert.
Mögliche Werte: 'true', 'false'
Default: 'instance_segmentation' = 'false'
Der Parameter 'instance_type' bestimmt, welcher Instanztyp für das Objektdetektion-Modell verwendet wird. Die Implementierungen unterscheiden sich bezüglich der erlaubten Orientierungen der umschließenden Rechtecke. Für weitere Erklärungen der verschiedenen Typen und ihren umschließenden Rechtecke wird auf das Kapitel Deep Learning / Objektdetektion und Instanz-Segmentierung verwiesen.
Mögliche Werte: 'rectangle1', 'rectangle2'
Default: 'instance_type' = 'rectangle1'
Tupel, das die Namen aller Layer des Modells enthält. Die Namen entsprechen
den von Menschen lesbaren Bezeichnern, die get_dl_model_param mit
'summary' zurückgibt.
Es ist zu beachten, dass für manche mit HALCON ausgelieferten
Modelle die Architektur vertraulich ist. In diesem Fall gibt
get_dl_model_param ein leeres Tupel für 'layer_names'
zurück.
Wert des Faktors, der den Einfluss des Gradienten während des
Trainings mit train_dl_model_batch bestimmt.
Mehr Informationen können in der Dokumentation von
train_dl_model_batch gefunden werden.
Der Standardwert ist vom Modell abhängig. Es ist zu beachten, dass eine Änderung von 'solver_type' den Wert von 'learning_rate' auf dessen Standardwert zurücksetzt.
Der Parameter 'learning_rate' hat keinen Einfluss.
Der Parameter 'mask_head_weight' ist ein Gewichtungsfaktor bei der Bestimmung der Gesamt-Zielfunktion. Dies bedeutet, dass beim Aufsummieren der einzelnen Zielfunktionswerte der Beitrag des Heads zur Vorhersage der Masken mit dem Faktor 'mask_head_weight' gewichtet wird.
Restriktion: Nur verfügbar für Modelle mit 'instance_segmentation'='true'
Default: 'mask_head_weight' = 1.0
Diese Parameter bestimmen, an welche Ebenen die zusätzlichen Netzwerke an die Merkmalspyramide angehängt werden. Für weitere Informationen zu Merkmalspyramiden und den angeschlossenen Netzwerken wird auf das Kapitel Deep Learning / Objektdetektion und Instanz-Segmentierung verwiesen.
Von diesen ('max_level' - 'min_level' + 1) Netzwerken werden alle Vorhersagen, die eine minimale Konfidenz und keine zu starke Überlappung aufweisen, beibehalten (siehe 'min_confidence' und 'max_overlap').
Die Ebene gibt an, wie oft die Größe der Merkmalskarte bereits herabskaliert wurde. Somit entspricht Ebene 0 den Merkmalskarten mit Größe des Eingabebildes, Ebene 1 den einmalig herabskalierten Merkmalskarten und so weiter. Kleinere Objekte werden daher besser auf den unteren Ebenen, größere Objekte auf den oberen Ebenen erkannt.
Falls 'max_level' größer ist als die Anzahl Ebenen des Backbones, wird das Backbone durch zusätzliche (zufällig initialisierte) Faltungs-Layer erweitert um tiefere Ebenen zu generieren. Dies bedeutet, dass 'max_level' einen Einfluss auf die minimale Größe der Eingabebilder haben kann.
Bei der Eingabe kleiner Bilddimensionen ist zu beachten, dass hohe Ebenen weniger aussagekräftig sein können, da die Merkmalskarten bereits zu klein sein könnten um aussagekräftige Informationen zu enthalten.
Eine höhere Anzahl verwendeter Ebenen kann zu einer Erhöhung von Laufzeit und Speicherplatz führen, wobei insbesondere die tiefen Ebenen ins Gewicht fallen.
Default: 'max_level' = 6, 'min_level' = 2
Dieser Parameter bestimmt die maximale Anzahl vom Netzwerk vorgeschlagener Detektionen (umschließende Rechtecke) pro Bild.
Default: 'max_num_detections' = 100
Der maximal zulässige Quotient aus Schnittmenge und Vereinigungsmenge (IoU, von engl. intersection over union) zweier umschließender Rechtecke derselben Klasse. Anders ausgedrückt, wenn zwei umschließende Rechtecke derselben Klasse zugeordnet werden und eine IoU höher als 'max_overlap' aufweisen, wird das Rechteck mit dem niedrigeren Konfidenzwert unterdrückt. Weitere Informationen zur IoU sind im Kapitel Deep Learning / Objektdetektion und Instanz-Segmentierung zu finden.
Default: 'max_overlap': = 0.5
Der maximal zulässige Quotient aus Schnittmenge und Vereinigungsmenge (IoU, von engl. intersection over union) zweier Rechtecke unabhängig ihrer Klasse. Anders ausgedrückt, wenn zwei umschließende Rechtecke eine IoU höher als 'max_overlap_class_agnostic' aufweisen, wird das Rechteck mit dem niedrigeren Konfidenzwert unterdrückt. Der Standardwert für 'max_overlap_class_agnostic' liegt bei 1.0, wodurch die Klassenagnostische Unterdrückung von umschließenden Rechtecken keine Auswirkung hat.
Default: 'max_overlap_class_agnostic' = 1.0
Dictionary mit benutzerdefinierten Meta-Daten, dessen Einträge frei gesetzt werden können. Die Meta-Daten können beispielsweise verwendet werden um zum Modell gehörige Information wie Versionsnummern oder Autor mit dem Modell abzuspeichern.
Restriktion: Als Dictionary-Werte sind nur Strings erlaubt.
Dieser Parameter bestimmt bei der Klassifizierung des Bildausschnitts
innerhalb des umschließenden Rechtecks die minimale Konfidenz um das
vorgeschlagene umschließende Rechteck beizubehalten.
Das heißt, wenn apply_dl_model aufgerufen wird, wird die
Ausgabe aller umschließender Rechtecke mit einem Konfidenzwert kleiner
als 'min_confidence' unterdrückt.
Default: 'min_confidence' = 0.5
Werden die Gewichte des Netzwerkes aktualisiert, gibt
der Hyperparameter 'momentum' an, zu welchem Ausmaß vorherige
Aktualisierungsvektoren im aktuellen Aktualisierungsvektor
berücksichtigt werden.
Dieser Hyperparameter ist nur für den 'solver_type' =
'sgd' verfügbar.
Für weitere Informationen verweisen wir auf die Dokumentation von
train_dl_model_batch.
Der Standardwert wird vom Modell gegeben.
Der Parameter 'momentum' hat keinen Einfluss.
Anzahl unterschiedlicher Klassen, die das Modell für seine Vorhersagen unterscheiden kann.
Dieser Parameter unterscheidet sich für die Modelltypen:
Dieser Wert wird über den Parameter NumClasses mit dem
Operator create_dl_model_detection gesetzt. Dabei müssen
'class_ids' und 'class_names' stets
'num_classes' Elemente haben.
Da ein Modell des Typs 'type'='segmentation' die Klasse 'background' vorhersagt, ist diese Klasse in 'num_classes' enthalten. Für diese Modelle wird 'num_classes' automatisch aus der Länge von 'class_ids' bestimmt.
Anzahl trainierbarer Parameter (Gewichte und Bias-Terme) des Modells. Dieser Wert ist ein Indikator für die Größe des Modells, wenn es serialisiert wird.
Definiert, ob das Modell optimiert und nur für die Inferenz anwendbar ist.
Das Modell bleibt auch nach der Optimierung auf HALCON
Standardeinheiten ausführbar (im Gegensatz zu
optimize_dl_model_for_inference).
Durch das Setzen des Parameterwertes auf 'true' wird der
Speicher freigegeben, den das Modell für die Inferenz nicht benötigt
(z.B. Speicher für die Gradienten).
Dies kann den Speicherbedarf des Modells signifikant reduzieren.
Infolgedessen sind bei Modellen mit dieser Eigenschaft keine Gradienten
verfügbar (z.B. notwendig für das Training oder die
Berechnung von Heatmaps).
Operatoren, welche Werte des freigegebenen Speichers verwenden
(z.B. train_dl_model_batch), setzen
diesen Parameter automatisch zurück auf 'false'.
Wird der Wert auf 'false' zurückgesetzt (egal ob manuell oder automatisch), wird der zum Trainieren benötigte Speicher erneut allokiert. Dies bedeutet, ein nachfolgendes Training verhält sich als ob 'momentum' kurzzeitig auf 0 gesetzt wäre (da mögliche Aktualisierungsvektoren erneut akkumuliert werden müssen).
Default: 'false'
Dieser Parameter bestimmt die Größe der Patches, d.h. der Bildausschnitte, die vom lokalen Netzwerk einzeln analysiert werden. Die Patchgröße sollte so gewählt werden, dass Patches, die Defekte enthalten, sich klar von defektfreien Patches unterscheiden lassen. Damit sollten alle Arten von Anomalien erkennbar sein, die bei der Inferenz vorkommen könnten. Die Patchgröße muss die Defektbereiche nicht vollständig abdecken. Es ist zu beachten, dass das Bild nicht in einzelne Patches aufgeteilt wird, sondern 'patch_size' nur den Maßstab bestimmt in dem das Bild schrittweise vom lokalen Subnetzwerk analysiert wird. Falls sich die Bildgröße ändert, sollte 'patch_size' dementsprechend angepasst werden.
| (1) | (2) |
Restriktion: Der Parameter 'patch_size' muss kleiner gleich 'image_width' und 'image_height' sein.
Default: 'patch_size' = 32
Definiert den Datentyp, der intern für die Berechnung eines Forward-Pass eines Deep Learning-Modells verwendet wird.
Default: 'float32'
Gibt an, ob das Modell nach dem Training einem Konvertierungsprozess über
optimize_dl_model_for_inference unterzogen wurde.
Default: 'false'
Standardmäßig von HALCON oder über eine AI2-Schnittstelle unterstützte Hardware-Einheit, auf der die Deep Learning Operatoren ausgeführt werden.
Beachte, der Parameter 'device' sollte bevorzugt zum Bestimmen der Hardware-Einheit, auf der die Deep Learning Operatoren ausgeführt werden, verwendet werden. Default: 'runtime' = 'gpu'
Die Trainings- und Inferenz-Operatoren werden auf der CPU ausgeführt.
Es ist zu beachten, dass das Training nur für spezifische Plattformen
unterstützt wird, siehe HALCON „Installation Guide“,
Abschnitt
„Requirements for Deep Learning and Deep-Learning-Based Methods“.
Falls zuvor auf der GPU gerechnet wurde, wird Speicher auf der CPU initialisiert und falls notwendig werden auf der GPU gespeicherte Werte auf die CPU verschoben.
Zur Parallelisierung:
Die Laufzeit ist stark abhängig von der Anzahl der gesetzten Threads, wobei
die Nutzung aller verfügbaren Threads nicht unbedingt zu einer schnelleren
Performance führt.
Die aktuell gesetzte Anzahl an Threads kann mit dem Operator
get_system abgefragt werden.
Die implementierte CPU Parallelisierung ist architekturabhängig:
Intel oder AMD Architekturen: OpenMP.
Dabei werden standardmäßig alle verfügbaren Threads der OpenMP
Laufzeitumgebung verwendet.
Die Anzahl der verwendeten Threads kann mit dem Parameter
'thread_num' des Operators set_system
spezifiziert werden.
Arm Architekturen: Globaler Thread Pool.
Die Anzahl der Threads kann mit dem globalen Parameter
'thread_num' des Operators set_system gesetzt werden.
Es ist nicht möglich für die gennanten Architekturen eine
thread-spezifische Anzahl von Threads (über den Parameter
'tsp_thread_num' des Operators set_system)
einzustellen.
Der Speicher wird auf der GPU initialisiert.
Die Operatoren apply_dl_model, train_dl_model_batch und
train_dl_model_anomaly_dataset werden auf der GPU ausgeführt.
Mehr Informationen zu diesen speziellen Voraussetzungen befinden
sich im HALCON „Installation Guide“.
Dieser Wert definiert den Optimierungsalgorithmus mit dem
Ziel der Minimierung der Gesamt-Zielfunktion.
Für mehr Informationen verweisen wir auf die Dokumentation von
train_dl_model_batch.
Folgende Werte sind setzbar:
'adam': Algorithmus für adaptive Moment-Schätzung
'sgd': Stochastisches Gradientenverfahren
Es ist zu beachten, dass eine Änderung von 'solver_type' den Wert von 'learning_rate' auf dessen Standardwert zurücksetzt.
Der Parameter 'solver_type' hat keinen Einfluss.
Der Anomalie-Score auf Bildebene wird intern als Mittelwert bestimmter
interner Scores s plus ein Vielfaches von deren Standardabweichung
berechnet.
Dabei bezeichnet s einen Pixelwert des internen
anomaly_image,
der Mittelwert von s und
die Standardabweichung von s.
Der Parameter 'standard_deviation_factor' setzt den Wert für
und steuert dadurch, wie stark die
Standardabweichung im Vergleich zum Mittelwert gewichtet wird.
Default: 'standard_deviation_factor' = 3.0
Mit diesem Parameter werden Informationen über die Layer des
Modells zurückgegeben.
Genauer gesagt wird ein Tupel zurückgegeben, welches für jeden
Layer einen String der folgenden Form enthält
ID; NAME; TYPE; OUTPUT_SHAPE; CONNECTED_NODES
ID: Index des Layers im CNN Graphen.
NAME: Von Menschen lesbarer Bezeichner (optional).
TYPE: Bezeichner für den Typ des Layers (z.B.
input oder convolution).
OUTPUT_SHAPE: Größe der Ausgabe in der
Form (Breite, Höhe, Tiefe,
'batch_size').
Dies bedeutet, der Layer hat Merkmalskarten der Größe Breite
mal Höhe und davon eine Anzahl entsprechend der Tiefe.
Zusammen bilden diese ein Ikonisches Objekt mit einem Kanal pro
Merkmalskarte.
Die verschiedenen Objekte sind die Layer-Ausgaben verschiedener
Samples.
Der Parameter 'batch_size' bestimmt, wie viele Objekte
zusammen zurückgegeben werden.
CONNECTED_NODES: Komma separierte Liste mit den Indices
der Layer, die die Ausgabe des aktuellen Layers als Eingabe
verwenden
Z.B.: '3; conv1; convolution; (112, 112, 64, 160); 4'.
Es ist zu beachten, dass für manche mit HALCON ausgelieferten
Modelle die Architektur vertraulich ist. In diesem Fall gibt
get_dl_model_param ein leeres Tupel für 'summary' zurück.
Dieser Parameter gibt den HALCON-spezifischen Modelltypen zurück. Folgende Typen werden unterschieden:
'3d_gripping_point_detection'
'anomaly_detection'
'classification'
'detection'
'gc_anomaly_detection'
'segmentation'
'ocr_recognition'
'generic' - für spezifische eingelesene oder mittels
Framework erstellte Modelle, siehe set_dl_model_param.
Regularisierungsparameter für die
Regularisierung der Zielfunktion.
Für eine genaue Beschreibung des Regularisierungsterms wird auf
train_dl_model_batch verwiesen.
Einfach gesagt begünstigt die Regularisierung einfachere
Modelle, die weniger anfällig sind, Rauschen in den Daten zu lernen.
Dadurch generalisieren diese Modelle in der Regel besser.
Für den Fall einer
Überanpassung des Klassifikators, empfehlen wir verschiedene Werte für
den Parameter 'weight_prior' zu testen.
Die Wahl des Wertes ist ein Abwägen zwischen der Fähigkeit des
Netzwerkes zu Generalisieren, einer Überanpassung oder einer
Unteranpassung. Ist zu klein, ist eine Überanpassung
möglich, ist es zu groß kann es passieren, dass das Modell seine
Fähigkeit verliert, sich an die Daten anzupassen, da dann alle
Gewichte effektiv Null sind. Um einen idealen Wert für
zu finden, empfehlen wir eine Kreuzvalidierung durchzuführen.
Das heißt, das Training wird für eine Reihe von Werten durchgeführt
und man wählt den Wert, der den besten Validierungsfehler liefert.
Üblich sind zum Testen die Werte für 'weight_prior' auf einer
logarithmischen Skala zwischen
.
Falls das Training sehr lange dauert, besteht die Möglichkeit für die
Optimierung der Hyperparameter einen reduzierten Datensatz zu
verwenden.
Der Parameter 'weight_prior' hat keinen Einfluss.
Default: 'weight_prior' = 0.0, mit der Ausnahme der vortrainierten Klassifikatoren:
pretrained_dl_classifier_resnet18:
'weight_prior' = 0.0001
pretrained_dl_classifier_resnet50:
'weight_prior' = 0.0001
pretrained_dl_classifier_alexnet:
'weight_prior' = 0.0005
DLModelHandle (input_control) dl_model → (handle)
Handle des Deep Learning-basierten Modells.
GenParamName (input_control) attribute.name → (string)
Name des generischen Parameters.
Defaultwert: 'batch_size'
Werteliste: 'adam_beta1', 'adam_beta2', 'adam_epsilon', 'alphabet', 'alphabet_internal', 'alphabet_mapping', 'anchor_angles', 'anchor_aspect_ratios', 'anchor_num_subscales', 'anomaly_score_tolerance', 'backbone', 'backbone_docking_layers', 'batch_size', 'batch_size_multiplier', 'bbox_heads_weight', 'capacity', 'class_heads_weight', 'class_ids', 'class_ids_no_orientation', 'class_names', 'class_weights', 'complexity', 'device', 'extract_feature_maps', 'freeze_backbone_level', 'gc_anomaly_networks', 'gpu', 'ignore_class_ids', 'ignore_direction', 'image_dimensions', 'image_height', 'image_num_channels', 'image_range_max', 'image_range_min', 'image_width', 'input_dimensions', 'instance_segmentation', 'instance_type', 'layer_names', 'learning_rate', 'mask_head_weight', 'max_level', 'max_num_detections', 'max_overlap', 'max_overlap_class_agnostic', 'meta_data', 'min_confidence', 'min_level', 'momentum', 'num_classes', 'num_trainable_params', 'optimize_for_inference', 'patch_size', 'precision', 'precision_is_converted', 'runtime', 'solver_type', 'standard_deviation_factor', 'summary', 'type', 'weight_prior'
GenParamValue (output_control) attribute.name(-array) → (integer / string / real)
Wert des generischen Parameters.
Sind die Parameterwerte korrekt, dann liefert
get_dl_model_param den Wert 2 (H_MSG_TRUE). Gegebenenfalls wird eine
Fehlerbehandlung durchgeführt.
read_dl_model,
set_dl_model_param
set_dl_model_param,
apply_dl_model,
train_dl_model_batch,
train_dl_model_anomaly_dataset
Foundation. Dieser Operator verwendet dynamische Lizensierung (siehe ``Installation Guide''). Welches der folgenden Module benötigt wird hängt von der Anwendung des Operators ab:
3D Metrology, OCR/OCV, Deep Learning Inference