Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Objekterkennung - TensorFlow
Der Amazon SageMaker AI Object Detection — TensorFlow Algorithmus ist ein überwachter Lernalgorithmus, der Transferlernen mit vielen vortrainierten Modellen aus dem [TensorFlow Model Garden](https://github.com/tensorflow/models) unterstützt. Verwenden Sie Transfer Learning, um eines der verfügbaren vortrainierten Modelle anhand Ihres eigenen Datensatzes zu optimieren, auch wenn eine große Menge an Bilddaten nicht verfügbar ist. Der Objekterkennungsalgorithmus verwendet ein Bild als Eingabe und gibt eine Liste von Begrenzungsrahmen aus. Trainingsdatensätze müssen aus Bildern bestehen. `jpg`,`.jpeg`, oder `.png` Format. Diese Seite enthält Informationen zu Amazon EC2 EC2-Instance-Empfehlungen und Beispiel-Notebooks für Object Detection - TensorFlow.
**Topics**
+ [So verwenden Sie den SageMaker KI-Objekterkennungsalgorithmus TensorFlow](object-detection-tensorflow-how-to-use.md)
+ [Eingabe- und Ausgabeschnittstelle für den TensorFlow Objekterkennungsalgorithmus](object-detection-tensorflow-inputoutput.md)
+ [Amazon EC2 EC2-Instance-Empfehlung für den Objekterkennungsalgorithmus TensorFlow](#object-detection-tensorflow-instances)
+ [Objekterkennung — TensorFlow Beispiel-Notizbücher](#object-detection-tensorflow-sample-notebooks)
+ [So TensorFlow funktioniert die Objekterkennung](object-detection-tensorflow-HowItWorks.md)
+ [TensorFlow Modelle](object-detection-tensorflow-Models.md)
+ [Objekterkennung — TensorFlow Hyperparameter](object-detection-tensorflow-Hyperparameter.md)
+ [Optimieren Sie ein Objekterkennungsmodell TensorFlow](object-detection-tensorflow-tuning.md)
# So verwenden Sie den SageMaker KI-Objekterkennungsalgorithmus TensorFlow
Sie können Object Detection TensorFlow als integrierten Algorithmus von Amazon SageMaker AI verwenden. Im folgenden Abschnitt wird beschrieben, wie die Objekterkennung TensorFlow mit dem SageMaker AI Python SDK verwendet wird. Informationen zur Verwendung der Objekterkennung — über die TensorFlow Amazon SageMaker Studio Classic-Benutzeroberfläche — finden Sie unter[SageMaker JumpStart vortrainierte Modelle](studio-jumpstart.md).
Der TensorFlow Objekterkennungsalgorithmus unterstützt Transfer Learning unter Verwendung eines der kompatiblen vortrainierten TensorFlow Modelle. Eine Liste aller verfügbaren vortrainierten Modelle finden Sie unter [TensorFlow Modelle](object-detection-tensorflow-Models.md). Jedes vortrainierte Modell hat ein Unikat `model_id`. Im folgenden Beispiel wird ResNet 50 (`model_id`:`tensorflow-od1-ssd-resnet50-v1-fpn-640x640-coco17-tpu-8`) zur Feinabstimmung eines benutzerdefinierten Datensatzes verwendet. Die vortrainierten Modelle werden alle vorab vom TensorFlow Hub heruntergeladen und in Amazon S3 S3-Buckets gespeichert, sodass Trainingsjobs netzwerkisoliert ausgeführt werden können. Verwenden Sie diese vorgenerierten Modelltrainingsartefakte, um einen AI Estimator zu erstellen. SageMaker
Rufen Sie zunächst den Docker-Image-URI, den Trainingsskript-URI und den vortrainierten Modell-URI ab. Ändern Sie dann die Hyperparameter nach Bedarf. Sie können ein Python-Wörterbuch mit allen verfügbaren Hyperparametern und ihren Standardwerten mit `hyperparameters.retrieve_default` sehen. Weitere Informationen finden Sie unter [Objekterkennung — TensorFlow Hyperparameter](object-detection-tensorflow-Hyperparameter.md). Verwenden Sie diese Werte, um einen SageMaker AI-Schätzer zu erstellen.
**Anmerkung**
Die Standard-Hyperparameterwerte sind für verschiedene Modelle unterschiedlich. Bei größeren Modellen ist die Standardanzahl von Epochen beispielsweise kleiner.
In diesem Beispiel wird der [https://www.cis.upenn.edu/~jshi/ped_html/#pub1](https://www.cis.upenn.edu/~jshi/ped_html/#pub1) Datensatz verwendet, der Bilder von Fußgängern auf der Straße enthält. Wir haben den Datensatz vorab heruntergeladen und mit Amazon S3 verfügbar gemacht. Rufen Sie zur Feinabstimmung Ihres Modells an, `.fit` indem Sie den Amazon S3-Speicherort Ihres Trainingsdatensatzes verwenden.
```
from sagemaker import image_uris, model_uris, script_uris, hyperparameters
from sagemaker.estimator import Estimator
model_id, model_version = "tensorflow-od1-ssd-resnet50-v1-fpn-640x640-coco17-tpu-8", "*"
training_instance_type = "ml.p3.2xlarge"
# Retrieve the Docker image
train_image_uri = image_uris.retrieve(model_id=model_id,model_version=model_version,image_scope="training",instance_type=training_instance_type,region=None,framework=None)
# Retrieve the training script
train_source_uri = script_uris.retrieve(model_id=model_id, model_version=model_version, script_scope="training")
# Retrieve the pretrained model tarball for transfer learning
train_model_uri = model_uris.retrieve(model_id=model_id, model_version=model_version, model_scope="training")
# Retrieve the default hyperparameters for fine-tuning the model
hyperparameters = hyperparameters.retrieve_default(model_id=model_id, model_version=model_version)
# [Optional] Override default hyperparameters with custom values
hyperparameters["epochs"] = "5"
# Sample training data is available in this bucket
training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
training_data_prefix = "training-datasets/PennFudanPed_COCO_format/"
training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}"
output_bucket = sess.default_bucket()
output_prefix = "jumpstart-example-od-training"
s3_output_location = f"s3://{output_bucket}/{output_prefix}/output"
# Create an Estimator instance
tf_od_estimator = Estimator(
role=aws_role,
image_uri=train_image_uri,
source_dir=train_source_uri,
model_uri=train_model_uri,
entry_point="transfer_learning.py",
instance_count=1,
instance_type=training_instance_type,
max_run=360000,
hyperparameters=hyperparameters,
output_path=s3_output_location,
)
# Launch a training job
tf_od_estimator.fit({"training": training_dataset_s3_path}, logs=True)
```
Weitere Informationen zur Verwendung des SageMaker TensorFlow KI-Objekterkennungsalgorithmus für Transfer-Lernen an einem benutzerdefinierten Datensatz finden Sie im Notizbuch [Einführung in die SageMaker TensorFlow Objekterkennung](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/object_detection_tensorflow/Amazon_Tensorflow_Object_Detection.ipynb).
# Eingabe- und Ausgabeschnittstelle für den TensorFlow Objekterkennungsalgorithmus
Jedes der unter Modelle aufgelisteten vortrainierten TensorFlow Modelle kann auf jeden Datensatz mit einer beliebigen Anzahl von Bildklassen abgestimmt werden. Achten Sie darauf, wie Sie Ihre Trainingsdaten für die Eingabe in das Objekterkennungsmodell formatieren. TensorFlow
+ **Eingabeformat für Trainingsdaten:** Ihre Trainingsdaten sollten ein Verzeichnis mit einem `images` Unterverzeichnis und einer `annotations.json` Datei sein.
Es folgt ein Beispiel für eine Eingabeverzeichnisstruktur. Das Eingabeverzeichnis sollte in einem Amazon-S3-Bucket mit einem Pfad gehostet werden, der dem folgenden ähnelt: `s3://bucket_name/input_directory/`. Beachten Sie, dass das Trailing `/` erforderlich ist.
```
input_directory
|--images
|--abc.png
|--def.png
|--annotations.json
```
Die `annotations.json` Datei sollte Informationen für Bounding Boxes und ihre Klassenbezeichnungen in Form eines Wörterbuchs `"images"` und `"annotations"` Schlüsseln enthalten. Der Wert für den `"images"` Schlüssel sollte eine Liste von Wörterbüchern sein. Für jedes Bild sollte es ein Wörterbuch mit den folgenden Informationen geben:. `{"file_name": image_name, "height": height, "width": width, "id": image_id}` Der Wert für den `"annotations"` Schlüssel sollte auch eine Liste von Wörterbüchern sein. Für jedes Begrenzungsfeld sollte es ein Wörterbuch mit den folgenden Informationen geben: `{"image_id": image_id, "bbox": [xmin, ymin, xmax, ymax], "category_id": bbox_label}`.
Nach dem Training werden eine Beschriftung-Mapping-Datei und ein trainiertes Modell in Ihrem Amazon-S3-Bucket gespeichert.
## Inkrementelles Training
Sie können das Training eines neuen Modells mit Artefakten aus einem Modell starten, das Sie zuvor mit SageMaker KI trainiert haben. Dieses inkrementelle Training verkürzt die Trainingsdauer, wenn Sie ein neues Modell mit denselben oder ähnlichen Daten trainieren möchten.
**Anmerkung**
Sie können ein SageMaker TensorFlow KI-Objekterkennungsmodell nur mit einem anderen in SageMaker KI trainierten TensorFlow Objekterkennungsmodell säen.
Sie können jeden Datensatz für das inkrementelle Training verwenden, solange der Klassensatz derselbe bleibt. Der inkrementelle Trainingsschritt ähnelt dem Feinabstimmungsschritt, aber anstatt mit einem vortrainierten Modell zu beginnen, beginnen Sie mit einem vorhandenen fein abgestimmten Modell. Weitere Informationen zur Nutzung des inkrementellen Trainings mit der SageMaker KI-Objekterkennung finden Sie im Notizbuch [Einführung in die SageMaker TensorFlow Objekterkennung](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/object_detection_tensorflow/Amazon_Tensorflow_Object_Detection.ipynb). TensorFlow
## Inferenz mit dem Objekterkennungsalgorithmus TensorFlow
Sie können das fein abgestimmte Modell, das aus Ihrem TensorFlow Objekterkennungstraining resultiert, als Inferenz hosten. Jedes Eingabebild für die Inferenz muss sich in `.jpg`, `jpeg` oder `.png`-Format befinden und vom Inhaltstyp `application/x-image` sein. Der TensorFlow Objekterkennungsalgorithmus passt die Größe der Eingabebilder automatisch an.
Das Ausführen von Inferenzen führt zu Begrenzungsfeldern, vorhergesagten Klassen und den Ergebnissen jeder Vorhersage, die im JSON-Format codiert sind. Das TensorFlow Objekterkennungsmodell verarbeitet ein einzelnes Bild pro Anfrage und gibt nur eine Zeile aus. Nachfolgend finden Sie ein Beispiel für eine Antwort im JSON Lines-Format:
```
accept: application/json;verbose
{"normalized_boxes":[[xmin1, xmax1, ymin1, ymax1],....],
"classes":[classidx1, class_idx2,...],
"scores":[score_1, score_2,...],
"labels": [label1, label2, ...],
"tensorflow_model_output":}
```
Wenn `accept` auf gesetzt `application/json` ist, gibt das Modell nur normalisierte Boxen, Klassen und Ergebnisse aus.
## Amazon EC2 EC2-Instance-Empfehlung für den Objekterkennungsalgorithmus TensorFlow
Der TensorFlow Objekterkennungsalgorithmus unterstützt alle GPU-Instances für das Training, einschließlich:
+ `ml.p2.xlarge`
+ `ml.p2.16xlarge`
+ `ml.p3.2xlarge`
+ `ml.p3.16xlarge`
Wir empfehlen die Verwendung von GPU-Instances mit mehr Arbeitsspeicher zum Training mit großen Stapelgrößen. Es können jedoch sowohl CPU-Instances (wie C5 und M5) als auch GPU-Instances (wie P2 und P3) für die Interferenz verwendet werden. Eine umfassende Liste der SageMaker Trainings- und Inferenzinstanzen in allen AWS Regionen finden Sie unter [ SageMaker Amazon-Preise](https://aws.amazon.com/sagemaker/pricing/).
## Objekterkennung — TensorFlow Beispiel-Notizbücher
Weitere Informationen zur Verwendung des SageMaker TensorFlow KI-Objekterkennungsalgorithmus für Transfer-Lernen an einem benutzerdefinierten Datensatz finden Sie im Notizbuch [Einführung in SageMaker TensorFlow — Objekterkennung](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/object_detection_tensorflow/Amazon_Tensorflow_Object_Detection.ipynb).
Anweisungen zum Erstellen und Zugreifen auf Jupyter-Notebook-Instanzen, mit denen Sie das Beispiel in SageMaker KI ausführen können, finden Sie unter. [SageMaker Amazon-Notebook-Instanzen](nbi.md) Nachdem Sie eine Notebook-Instanz erstellt und geöffnet haben, wählen Sie die Registerkarte **SageMaker KI-Beispiele** aus, um eine Liste aller KI-Beispiele anzuzeigen. SageMaker Zum Öffnen eines Notebooks wählen Sie die Registerkarte **Verwenden** und dann **Kopie erstellen** aus.
# So TensorFlow funktioniert die Objekterkennung
Der TensorFlow Objekterkennungsalgorithmus verwendet ein Bild als Eingabe und sagt Begrenzungsrahmen und Objektbeschriftungen voraus. Verschiedene Deep-Learning-Netzwerke wie MobileNet, ResNet, Inception und EfficientNet sind äußerst präzise für die Objekterkennung. Es gibt auch Deep-Learning-Netzwerke, die auf großen Bilddatensätzen trainiert werden, wie beispielsweise Common Objects in Context (COCO), das 328.000 Bilder enthält. Nachdem ein Netzwerk mit COCO-Daten trainiert wurde, können Sie das Netzwerk anhand eines Datensatzes mit einem bestimmten Fokus feinabstimmen, um spezifischere Aufgaben zur Objekterkennung auszuführen. Der Amazon SageMaker AI Object Detection — TensorFlow Algorithmus unterstützt Transfer Learning auf vielen vortrainierten Modellen, die im TensorFlow Model Garden verfügbar sind.
Je nach Anzahl der Klassenbezeichnungen in Ihren Trainingsdaten wird dem vortrainierten TensorFlow Modell Ihrer Wahl eine Objekterkennungsebene hinzugefügt. Anschließend können Sie entweder das gesamte Netzwerk (einschließlich des vortrainierten Modells) oder nur die oberste Klassifizierungsebene für neue Trainingsdaten feinabstimmen. Mit dieser Methode des Transfer Learning ist ein Training mit kleineren Datensätzen möglich.
# TensorFlow Modelle
Die folgenden vortrainierten Modelle können für das Transferlernen mit dem TensorFlow Objekterkennungsalgorithmus verwendet werden.
Die folgenden Modelle unterscheiden sich erheblich in Größe, Anzahl der Modellparameter, Trainingszeit und Inferenzlatenz für einen bestimmten Datensatz. Welches Modell am besten für Ihren Anwendungsfall geeignet ist, hängt von der Komplexität Ihres Feinabstimmungsdatensatzes und allen Anforderungen ab, die Sie an Trainingszeit, Inferenzlatenz oder Modellgenauigkeit haben.
| Modellname | `model_id` | Quelle |
| --- | --- | --- |
| ResNet50 V1 FPN 640 | `tensorflow-od1-ssd-resnet50-v1-fpn-640x640-coco17-tpu-8` | [TensorFlow Modell Garden Link](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_resnet50_v1_fpn_640x640_coco17_tpu-8.tar.gz) |
| EfficientDet D0 512 | `tensorflow-od1-ssd-efficientdet-d0-512x512-coco17-tpu-8` | [TensorFlow Modell Garden Link](http://download.tensorflow.org/models/object_detection/tf2/20200711/efficientdet_d0_coco17_tpu-32.tar.gz) |
| EfficientDet D1 640 | `tensorflow-od1-ssd-efficientdet-d1-640x640-coco17-tpu-8` | [TensorFlow Modell Garden Link](http://download.tensorflow.org/models/object_detection/tf2/20200711/efficientdet_d1_coco17_tpu-32.tar.gz) |
| EfficientDet D2 768 | `tensorflow-od1-ssd-efficientdet-d2-768x768-coco17-tpu-8` | [TensorFlow Modell Garden Link](http://download.tensorflow.org/models/object_detection/tf2/20200711/efficientdet_d2_coco17_tpu-32.tar.gz) |
| EfficientDet D3 896 | `tensorflow-od1-ssd-efficientdet-d3-896x896-coco17-tpu-32` | [TensorFlow Modell Garden Link](http://download.tensorflow.org/models/object_detection/tf2/20200711/efficientdet_d3_coco17_tpu-32.tar.gz) |
| MobileNet V1 FPN 640 | `tensorflow-od1-ssd-mobilenet-v1-fpn-640x640-coco17-tpu-8` | [TensorFlow Modell Garden Link](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_mobilenet_v1_fpn_640x640_coco17_tpu-8.tar.gz) |
| MobileNet V2 FPNLite 320 | `tensorflow-od1-ssd-mobilenet-v2-fpnlite-320x320-coco17-tpu-8` | [TensorFlow Modell Garden Link](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_mobilenet_v2_fpnlite_320x320_coco17_tpu-8.tar.gz) |
| MobileNet V2 FPNLite 640 | `tensorflow-od1-ssd-mobilenet-v2-fpnlite-640x640-coco17-tpu-8` | [TensorFlow Modell Garden Link](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_mobilenet_v2_fpnlite_640x640_coco17_tpu-8.tar.gz) |
| ResNet50 V1 FPN 1024 | `tensorflow-od1-ssd-resnet50-v1-fpn-1024x1024-coco17-tpu-8` | [TensorFlow Modell Garden Link](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_resnet50_v1_fpn_1024x1024_coco17_tpu-8.tar.gz) |
| ResNet101 V1 FPN 640 | `tensorflow-od1-ssd-resnet101-v1-fpn-640x640-coco17-tpu-8` | [TensorFlow Modell Garden Link](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_resnet101_v1_fpn_640x640_coco17_tpu-8.tar.gz) |
| ResNet101 V1 FPN 1024 | `tensorflow-od1-ssd-resnet101-v1-fpn-1024x1024-coco17-tpu-8` | [TensorFlow Modell Garden Link](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_resnet101_v1_fpn_1024x1024_coco17_tpu-8.tar.gz) |
| ResNet152 V1 FPN 640 | `tensorflow-od1-ssd-resnet152-v1-fpn-640x640-coco17-tpu-8` | [TensorFlow Modell Garden Link](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_resnet152_v1_fpn_640x640_coco17_tpu-8.tar.gz) |
| ResNet152 V1 FPN 1024 | `tensorflow-od1-ssd-resnet152-v1-fpn-1024x1024-coco17-tpu-8` | [TensorFlow Modell Garden Link](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_resnet152_v1_fpn_1024x1024_coco17_tpu-8.tar.gz) |
# Objekterkennung — TensorFlow Hyperparameter
Hyperparameter sind Parameter, die festgelegt werden, bevor ein Machine-Learning-Modell mit dem Lernen beginnt. Die folgenden Hyperparameter werden vom in Amazon SageMaker AI integrierten TensorFlow Objekterkennungsalgorithmus unterstützt. Weitere Informationen zur Hyperparameter-Optimierung finden Sie unter [Optimieren Sie ein Objekterkennungsmodell TensorFlow](object-detection-tensorflow-tuning.md).
| Name des Parameters | Description |
| --- | --- |
| batch\$1size | Die Batch-Größe für das Training. Gültige Werte: positive Ganzzahl. Standardwert: `3`. |
| beta\$11 | Die Beta1-Version für den `"adam"` Optimierer. Die exponentielle Zerfallsrate für Schätzwerte im ersten Schritt. Wird für andere Optimierer ignoriert. Gültige Werte: Float, Bereich: [`0.0`, `1.0`]. Standardwert: `0.9`. |
| beta\$12 | Die Beta2 für den Optimierer. `"adam"` Die exponentielle Zerfallsrate für Schätzwerte im zweiten Schritt. Wird für andere Optimierer ignoriert. Gültige Werte: Float, Bereich: [`0.0`, `1.0`]. Standardwert: `0.999`. |
| early\$1stopping | Auf `"True"` eingestellt, um die Logik zum vorzeitigen Abbruch während des Trainings zu verwenden. Falls `"False"`, wird vorzeitiges Abbrechen nicht verwendet. Gültige Werte: Zeichenfolge, entweder: (`"True"` oder `"False"`). Standardwert: `"False"`. |
| early\$1stopping\$1min\$1delta | Die geringste Änderung, die erforderlich ist, um als Verbesserung zu gelten. Eine absolute Änderung, die unter dem Wert von early\$1stopping\$1min\$1delta liegt, gilt nicht als Verbesserung. Wird nur verwendet, wenn für early\$1stopping der Wert "True" festgelegt ist.Gültige Werte: Float, Bereich: [`0.0`, `1.0`].Standardwert: `0.0`. |
| early\$1stopping\$1patience | Die Anzahl der Epochen, in denen die Ausbildung ohne Verbesserung fortgesetzt wird. Wird nur verwendet, wenn für `early_stopping` der Wert `"True"` festgelegt ist. Gültige Werte: positive Ganzzahl. Standardwert: `5`. |
| epochs | Die Anzahl der Trainingsepochen. Gültige Werte: positive Ganzzahl. Standardwert: `5` für kleinere Modelle, `1` für größere Modelle. |
| epsilon | Das Epsilon für `"adam"`, `"rmsprop"`, `"adadelta"`, und `"adagrad"` Optimierer. Normalerweise auf einen kleinen Wert eingestellt, um eine Division durch 0 zu vermeiden. Wird für andere Optimierer ignoriert. Gültige Werte: Float, Bereich: [`0.0`, `1.0`]. Standardwert: `1e-7`. |
| initial\$1accumulator\$1value | Der Startwert für die Akkumulatoren oder die Impulswerte pro Parameter für den `"adagrad"` Optimierer. Wird für andere Optimierer ignoriert. Gültige Werte: Float, Bereich: [`0.0`, `1.0`]. Standardwert: `0.1`. |
| learning\$1rate | Die Lernrate des Optimierers. Gültige Werte: Float, Bereich: [`0.0`, `1.0`].Standardwert: `0.001`. |
| momentum | Der Schwung für die `"sgd"` und `"nesterov"` Optimierer. Wird für andere Optimierer ignoriert. Gültige Werte: Float, Bereich: [`0.0`, `1.0`]. Standardwert: `0.9`. |
| optimizer | Der Optimierer-Typ. Weitere Informationen finden Sie in der [Dokumentation unter Optimizer](https://www.tensorflow.org/api_docs/python/tf/keras/optimizers). TensorFlow Gültige Werte: Zeichenfolge, einer der folgenden Werte: (`"adam"`, `"sgd"`, `"nesterov"`, `"rmsprop"`,` "adagrad"` , `"adadelta"`). Standardwert: `"adam"`. |
| reinitialize\$1top\$1layer | Wenn dieser Wert auf `"Auto"` gesetzt ist, werden die Parameter der obersten Klassifikationsschicht während der Feinabstimmung neu initialisiert. Beim inkrementellen Training werden die Parameter der obersten Klassifikationsschicht nur dann neu initialisiert, wenn sie auf `"True"` gesetzt sind. Gültige Werte: Zeichenfolge, einer der folgenden Werte: (`"Auto"`, `"True"` oder `"False"`). Standardwert: `"Auto"`. |
| rho | Der Abzinsungsfaktor für den Gradienten der `"adadelta"` und `"rmsprop"` Optimierer. Wird für andere Optimierer ignoriert. Gültige Werte: Float, Bereich: [`0.0`, `1.0`]. Standardwert: `0.95`. |
| train\$1only\$1on\$1top\$1layer | Falls `"True"`, werden nur die Parameter der obersten Klassifikationsschicht fein abgestimmt. Falls `"False"`, werden alle Modellparameter fein abgestimmt. Gültige Werte: Zeichenfolge, entweder: (`"True"` or `"False"`). Standardwert: `"False"`. |
# Optimieren Sie ein Objekterkennungsmodell TensorFlow
Die *automatische Modelloptimierung*, auch bekannt als Hyperparameteroptimierung, sucht die beste Version eines Modells, indem viele Aufträge ausgeführt werden, die einen Bereich von Hyperparametern in Ihrem Datensatz testen. Sie wählen die optimierbaren Hyperparameter, eine Reihe von Werten für jeden Parameter und eine objektive Metrik aus. Sie wählen die objektive Metrik aus den Metriken aus, die der Algorithmus berechnet. Die automatische Modelloptimierung durchsucht die ausgewählten Hyperparameter nach der Kombination von Werten, die das Modell ergeben, das die objektive Metrik optimiert.
Mehr Informationen über die Modelloptimierung finden Sie unter [Automatische Modelloptimierung mit KI SageMaker](automatic-model-tuning.md).
## Mit dem Object Detection — Algorithmus berechnete Metriken TensorFlow
In der folgenden Tabelle können Sie herausfinden, welche Metriken vom Objekterkennungsalgorithmus berechnet werden. TensorFlow
| Metrikname | Description | Optimierungsrichtung | Regex-Musterung |
| --- | --- | --- | --- |
| validation:localization\$1loss | Der Lokalisierungsverlust bei der Box-Vorhersage. | Minimieren | `Val_localization=([0-9\\.]+)` |
## Einstellbare Objekterkennung — Hyperparameter TensorFlow
Stimmen Sie ein Objekterkennungsmodell mit den folgenden Hyperparametern ab. Die Hyperparameter mit den größten Auswirkungen auf objektive Objekterkennungsmetrik sind: `batch_size`, `learning_rate` und `optimizer`. Optimieren Sie die auf den Optimierer bezogenen Hyperparameter, wie `momentum`, `regularizers_l2`, `beta_1`, `beta_2` und `eps` basierend auf dem ausgewählten `optimizer`. Verwenden Sie z. B. `beta_1` und `beta_2` nur, wenn `adam` der `optimizer` ist.
Weitere Informationen dazu, welche Hyperparameter für die einzelnen `optimizer` verwendet werden, finden Sie unter [Objekterkennung — TensorFlow Hyperparameter](object-detection-tensorflow-Hyperparameter.md).
| Name des Parameters | Parametertyp | Empfohlene Bereiche |
| --- | --- | --- |
| batch\$1size | IntegerParameterRanges | MinValue: 8, MaxValue: 512 |
| beta\$11 | ContinuousParameterRanges | MinValue: 1e-6, MaxValue: 0,99 |
| beta\$12 | ContinuousParameterRanges | MinValue: 1e-6,: 0,999 MaxValue |
| eps | ContinuousParameterRanges | MinValue: 1e-8,: 1,0 MaxValue |
| learning\$1rate | ContinuousParameterRanges | MinValue: 1e-6,: 0,5 MaxValue |
| momentum | ContinuousParameterRanges | MinValue: 0,0,: 0,99 MaxValue |
| optimizer | CategoricalParameterRanges | ['sgd', 'adam', 'rmsprop', 'nesterov', 'adagrad', 'adadelta'] |
| regularizers\$1l2 | ContinuousParameterRanges | MinValue: 0,0, MaxValue: 0,99 |
| train\$1only\$1on\$1top\$1layer | CategoricalParameterRanges | ['True', 'False'] |
| initial\$1accumulator\$1value | CategoricalParameterRanges | MinValue: 0,0, MaxValue: 0,99 |