Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Détection d'objets - TensorFlow
L'algorithme Amazon SageMaker AI Object Detection est un TensorFlow algorithme d'apprentissage supervisé qui prend en charge l'apprentissage par transfert avec de nombreux modèles préentraînés issus du [TensorFlow Model Garden](https://github.com/tensorflow/models). Utilisez l'apprentissage par transfert pour affiner l'un des modèles pré-entraînés disponibles sur votre propre jeu de données, même si une grande quantité de données d'image n'est pas disponible. L'algorithme de détection d'objets prend une image en entrée et génère en sortie une liste de zones de délimitation. Les jeux de données d'entraînement doivent être composés d'images au format `jpg`, `.jpeg` ou `.png`. Cette page inclut des informations sur les recommandations relatives aux instances Amazon EC2 et des exemples de blocs-notes pour la détection d'objets -. TensorFlow
**Topics**
+ [Comment utiliser l' TensorFlow algorithme SageMaker AI Object Detection](object-detection-tensorflow-how-to-use.md)
+ [Interface d'entrée et de sortie pour l' TensorFlow algorithme de détection d'objets](object-detection-tensorflow-inputoutput.md)
+ [Recommandation d'instance Amazon EC2 pour l'algorithme de détection d'objets TensorFlow](#object-detection-tensorflow-instances)
+ [Détection d'objets - TensorFlow exemples de carnets](#object-detection-tensorflow-sample-notebooks)
+ [Comment TensorFlow fonctionne la détection d'objets](object-detection-tensorflow-HowItWorks.md)
+ [TensorFlow Modèles](object-detection-tensorflow-Models.md)
+ [Détection d'objets - TensorFlow Hyperparamètres](object-detection-tensorflow-Hyperparameter.md)
+ [Régler la détection d'un objet - TensorFlow modèle](object-detection-tensorflow-tuning.md)
# Comment utiliser l' TensorFlow algorithme SageMaker AI Object Detection
Vous pouvez utiliser Object Detection TensorFlow en tant qu'algorithme intégré d'Amazon SageMaker AI. La section suivante décrit comment utiliser la détection d'objets TensorFlow avec le SDK SageMaker AI Python. Pour plus d'informations sur l'utilisation de la détection d'objets, TensorFlow depuis l'interface utilisateur Amazon SageMaker Studio Classic, consultez[SageMaker JumpStart modèles préentraînés](studio-jumpstart.md).
L' TensorFlow algorithme Object Detection prend en charge l'apprentissage par transfert à l'aide de l'un des TensorFlow modèles préentraînés compatibles. Pour obtenir la liste de tous les modèles pré-entraînés disponibles, consultez [TensorFlow Modèles](object-detection-tensorflow-Models.md). Chaque modèle pré-entraîné possède un `model_id` unique. L'exemple suivant utilise ResNet 50 (`model_id`:`tensorflow-od1-ssd-resnet50-v1-fpn-640x640-coco17-tpu-8`) pour affiner un ensemble de données personnalisé. Les modèles préentraînés sont tous prétéléchargés depuis le TensorFlow Hub et stockés dans des compartiments Amazon S3 afin que les tâches de formation puissent être exécutées de manière isolée sur le réseau. Utilisez ces artefacts d'entraînement de modèles prégénérés pour créer un estimateur d' SageMaker IA.
Tout d'abord, récupérez l'URI de l'image Docker, l'URI du script d'entraînement et l'URI du modèle pré-entraîné. Ensuite, modifiez les hyperparamètres comme bon vous semble. Vous pouvez consulter un dictionnaire Python de tous les hyperparamètres disponibles et de leurs valeurs par défaut avec `hyperparameters.retrieve_default`. Pour de plus amples informations, veuillez consulter [Détection d'objets - TensorFlow Hyperparamètres](object-detection-tensorflow-Hyperparameter.md). Utilisez ces valeurs pour créer un estimateur SageMaker AI.
**Note**
Les valeurs par défaut des hyperparamètres sont différentes selon les modèles. Par exemple, pour les modèles plus grands, le nombre d'époques par défaut est inférieur.
Cet exemple utilise le jeu de données [https://www.cis.upenn.edu/~jshi/ped_html/#pub1](https://www.cis.upenn.edu/~jshi/ped_html/#pub1), qui contient des images de piétons dans la rue. Nous avons pré-téléchargé le jeu de données et l'avons mis à disposition avec Amazon S3. Pour affiner votre modèle, appelez `.fit` à l'aide de l'emplacement Amazon S3 de votre jeu de données d'entraînement.
```
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)
```
Pour plus d'informations sur l'utilisation de l' TensorFlow algorithme SageMaker AI Object Detection pour l'apprentissage par transfert sur un ensemble de données personnalisé, consultez le bloc-notes [Introduction to SageMaker TensorFlow - Object Detection](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/object_detection_tensorflow/Amazon_Tensorflow_Object_Detection.ipynb).
# Interface d'entrée et de sortie pour l' TensorFlow algorithme de détection d'objets
Chacun des modèles préentraînés répertoriés dans TensorFlow Modèles peut être affiné pour n'importe quel ensemble de données contenant un certain nombre de classes d'images. Sachez comment formater vos données d'entraînement pour les saisir dans le TensorFlow modèle de détection d'objets.
+ **Training data input format** (Format d'entrée des données d'entraînement) : vos données d'entraînement doivent être dans un sous-répertoire nommé `images`, contenant un fichier `annotations.json`.
Voici un exemple de structure du répertoire d'entrée. Le répertoire d'entrée doit être hébergé dans un compartiment Amazon S3 avec un chemin similaire au suivant : `s3://bucket_name/input_directory/`. Notez que le `/` de fin est obligatoire.
```
input_directory
|--images
|--abc.png
|--def.png
|--annotations.json
```
Le fichier `annotations.json` doit contenir des informations sur les cadres de délimitation et leurs étiquettes de classe sous la forme d'un dictionnaire `"images"` et de clés `"annotations"`. La valeur de la clé `"images"` doit être une liste de dictionnaires. Il doit y avoir un dictionnaire pour chaque image avec les informations suivantes : `{"file_name": image_name, "height": height, "width": width, "id": image_id}`. La valeur de la clé `"annotations"` doit également être une liste de dictionnaires. Il doit y avoir un dictionnaire pour chaque cadre de délimitation avec les informations suivantes : `{"image_id": image_id, "bbox": [xmin, ymin, xmax, ymax], "category_id": bbox_label}`.
Après la formation, un fichier de mappage d'étiquettes et un modèle entraîné sont enregistrés dans votre compartiment Amazon S3.
## Entraînement incrémentiel
Vous pouvez amorcer l'entraînement d'un nouveau modèle à l'aide d'artefacts provenant d'un modèle que vous avez déjà entraîné avec l' SageMaker IA. L'entraînement incrémentiel permet de gagner du temps lorsque vous souhaitez entraîner un nouveau modèle avec des données identiques ou similaires.
**Note**
Vous pouvez uniquement associer un modèle de détection d'objets par SageMaker IA à un autre TensorFlow modèle de détection d'objets entraîné par l' SageMaker IA. TensorFlow
Vous pouvez utiliser n'importe quel jeu de données pour l'entraînement incrémentiel, à condition que l'ensemble de classes reste le même. L'étape d'entraînement incrémentiel est similaire à l'étape d'affinage, mais au lieu de commencer par un modèle pré-entraîné, vous commencez par un modèle affiné existant. Pour plus d'informations sur l'utilisation de l'entraînement progressif avec la détection d'objets SageMaker AI TensorFlow, consultez le bloc-notes [Introduction à SageMaker TensorFlow la détection d'objets](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/object_detection_tensorflow/Amazon_Tensorflow_Object_Detection.ipynb).
## Inférence avec l'algorithme de détection d'objets TensorFlow
Vous pouvez héberger le modèle affiné issu de votre entraînement à la détection d' TensorFlow objets à des fins d'inférence. Toute image d'entrée pour l'inférence doit être au format `.jpg`, .`jpeg` ou `.png` et présenter un type de contenu `application/x-image`. L' TensorFlow algorithme Object Detection - redimensionne automatiquement les images d'entrée.
L'exécution de l'inférence donne des cadres de délimitation, des classes prédites et les scores de chaque prédiction codée au format JSON. Le TensorFlow modèle Object Detection - traite une seule image par demande et ne produit qu'une seule ligne. Voici un exemple de réponse au format JSON :
```
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":}
```
Si `accept` est défini sur `application/json`, le modèle ne génère que des boîtes, des classes et des scores normalisés.
## Recommandation d'instance Amazon EC2 pour l'algorithme de détection d'objets TensorFlow
L' TensorFlow algorithme Object Detection - prend en charge toutes les instances de GPU pour l'entraînement, notamment :
+ `ml.p2.xlarge`
+ `ml.p2.16xlarge`
+ `ml.p3.2xlarge`
+ `ml.p3.16xlarge`
Nous recommandons d'utiliser les instances de GPU avec davantage de mémoire pour l'entraînement avec de grandes tailles de lot. Les instances de CPU (telles que M5) et de GPU (P2 ou P3) peuvent être utilisées pour l'inférence. Pour obtenir une liste complète des instances de SageMaker formation et d'inférence dans toutes AWS les régions, consultez [Amazon SageMaker Pricing](https://aws.amazon.com/sagemaker/pricing/).
## Détection d'objets - TensorFlow exemples de carnets
Pour plus d'informations sur l'utilisation de l' TensorFlow algorithme SageMaker AI Object Detection pour l'apprentissage par transfert sur un ensemble de données personnalisé, consultez le bloc-notes [Introduction to SageMaker TensorFlow - Object Detection](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/object_detection_tensorflow/Amazon_Tensorflow_Object_Detection.ipynb).
Pour savoir comment créer et accéder à des instances de bloc-notes Jupyter que vous pouvez utiliser pour exécuter l'exemple dans SageMaker AI, consultez. [Instances de SageMaker blocs-notes Amazon](nbi.md) Après avoir créé une instance de bloc-notes et l'avoir ouverte, sélectionnez l'onglet **Exemples d'SageMaker IA** pour voir la liste de tous les exemples d' SageMaker IA. Pour ouvrir un bloc-notes, choisissez son onglet **Use** (Utiliser), puis **Create copy** (Créer une copie).
# Comment TensorFlow fonctionne la détection d'objets
L' TensorFlow algorithme Object Detection - prend une image en entrée et prédit les cadres de délimitation et les étiquettes des objets. Divers réseaux d'apprentissage en profondeur tels que MobileNet, ResNet, Inception et EfficientNet sont très précis pour la détection d'objets. Il existe également des réseaux de deep learning qui sont entraînés sur de grands jeux de données d'images, tels que Common Objects in Context, qui contient 328 000 images. Une fois qu'un réseau a été entraîné avec les données de COCO, vous pouvez affiner le réseau sur un jeu de données en mettant l'accent sur l'exécution de tâches de détection d'objet plus spécifiques. L' TensorFlow algorithme Amazon SageMaker AI Object Detection prend en charge l'apprentissage par transfert sur de nombreux modèles préentraînés disponibles dans le TensorFlow Model Garden.
En fonction du nombre d'étiquettes de classe figurant dans vos données d'entraînement, une couche de détection d'objets est attachée au TensorFlow modèle préentraîné de votre choix. Vous pouvez ensuite affiner le réseau entier (y compris le modèle pré-entraîné) ou uniquement la couche de classification supérieure sur les nouvelles données d'entraînement. Avec cette méthode d'apprentissage par transfert, un entraînement avec des jeux de données plus petits est possible.
# TensorFlow Modèles
Les modèles préentraînés suivants peuvent être utilisés pour l'apprentissage par transfert avec l' TensorFlow algorithme de détection d'objets.
Les modèles suivants varient de manière significative par leur taille, le nombre de paramètres de modèle, la durée d'entraînement et la latence d'inférence pour n'importe quel jeu de données. Le meilleur modèle pour votre cas d'utilisation dépend de la complexité de l'affinage du jeu de données et de toutes vos exigences en matière de durée d'entraînement, de latence d'inférence ou de précision du modèle.
| Nom du modèle | `model_id` | Source |
| --- | --- | --- |
| ResNet50 V1 FPN 640 | `tensorflow-od1-ssd-resnet50-v1-fpn-640x640-coco17-tpu-8` | [TensorFlow Model 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 Model 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 Model 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 Model 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 Model 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 Model 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 Model 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 Model Garden link](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_mobilenet_v2_fpnlite_640x640_coco17_tpu-8.tar.gz) |
| ResNet50 V1 VPN 1024 | `tensorflow-od1-ssd-resnet50-v1-fpn-1024x1024-coco17-tpu-8` | [TensorFlow Model 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 Model 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 Model 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 Model 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 Model Garden link](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_resnet152_v1_fpn_1024x1024_coco17_tpu-8.tar.gz) |
# Détection d'objets - TensorFlow Hyperparamètres
Les hyperparamètres sont des paramètres définis avant qu'un modèle de machine learning ne commence à apprendre. Les hyperparamètres suivants sont pris en charge par l' TensorFlow algorithme intégré de détection d'objets d'Amazon SageMaker AI. Consultez [Régler la détection d'un objet - TensorFlow modèle](object-detection-tensorflow-tuning.md) pour obtenir des informations sur le réglage des hyperparamètres.
| Nom du paramètre | Description |
| --- | --- |
| batch\$1size | Taille de lot pour l'entraînement. Valeurs valides : nombre entier positif. Valeur par défaut : `3`. |
| beta\$11 | Version beta1 de l'optimiseur `"adam"`. Représente le taux de dégradation exponentielle pour les estimations du premier moment. Ignoré pour les autres optimiseurs. Valeurs valides : valeur à virgule flottante, plage : [`0.0`, `1.0`]. Valeur par défaut : `0.9`. |
| beta\$12 | Version beta2 de l'optimiseur `"adam"`. Représente le taux de dégradation exponentielle pour les estimations du second moment. Ignoré pour les autres optimiseurs. Valeurs valides : valeur à virgule flottante, plage : [`0.0`, `1.0`]. Valeur par défaut : `0.999`. |
| early\$1stopping | Définissez ce paramètre sur `"True"` pour utiliser une logique d'arrêt anticipé au cours de l'entraînement. S'il a pour valeur `"False"`, l'arrêt anticipé n'est pas utilisé. Valeurs valides : chaîne, valeur : (`"True"` ou `"False"`). Valeur par défaut : `"False"`. |
| early\$1stopping\$1min\$1delta | Modification minimale requise pour être considérée comme une amélioration. Une modification absolue inférieure à la valeur de early\$1stopping\$1min\$1delta ne constitue pas une amélioration. Utilisé uniquement quand early\$1stopping a pour valeur "True".Valeurs valides : valeur à virgule flottante, plage : [`0.0`, `1.0`].Valeur par défaut : `0.0`. |
| early\$1stopping\$1patience | Nombre d'époques pour continuer l'entraînement sans amélioration. Utilisé uniquement quand `early_stopping` a pour valeur `"True"`. Valeurs valides : nombre entier positif. Valeur par défaut : `5`. |
| epochs | Nombre de dates epoch d'entraînement. Valeurs valides : nombre entier positif. Valeur par défaut : `5` pour les modèles plus petits, `1` pour les modèles plus grands. |
| epsilon | Epsilon des optimiseurs `"adam"`, `"rmsprop"`, `"adadelta"` et `"adagrad"`. Généralement défini sur une petite valeur pour éviter la division par 0. Ignoré pour les autres optimiseurs. Valeurs valides : valeur à virgule flottante, plage : [`0.0`, `1.0`]. Valeur par défaut : `1e-7`. |
| initial\$1accumulator\$1value | Valeur de départ pour les accumulateurs, ou valeurs de moment par paramètre, pour l'optimiseur `"adagrad"`. Ignoré pour les autres optimiseurs. Valeurs valides : valeur à virgule flottante, plage : [`0.0`, `1.0`]. Valeur par défaut : `0.1`. |
| learning\$1rate | Taux d'apprentissage de l'optimiseur. Valeurs valides : valeur à virgule flottante, plage : [`0.0`, `1.0`].Valeur par défaut : `0.001`. |
| momentum | Moment pour les optimiseurs `"sgd"` et `"nesterov"`. Ignoré pour les autres optimiseurs. Valeurs valides : valeur à virgule flottante, plage : [`0.0`, `1.0`]. Valeur par défaut : `0.9`. |
| optimizer | Type d'optimiseur. Pour plus d'informations, consultez la section [Optimiseurs](https://www.tensorflow.org/api_docs/python/tf/keras/optimizers) dans la TensorFlow documentation. Valeurs valides : chaîne, l'une des valeurs suivantes : (`"adam"`, `"sgd"`, `"nesterov"`, `"rmsprop"`, ` "adagrad"`, `"adadelta"`). Valeur par défaut : `"adam"`. |
| reinitialize\$1top\$1layer | Si ce paramètre a pour valeur `"Auto"`, les paramètres de la couche de classification supérieure sont réinitialisés au cours de l'affinage. Pour l'entraînement incrémentiel, les paramètres de la couche de classification supérieure ne sont pas réinitialisés à moins d'être définis sur `"True"`. Valeurs valides : chaîne, l'une des valeurs suivantes : (`"Auto"`, `"True"` ou `"False"`). Valeur par défaut : `"Auto"`. |
| rho | Facteur de déduction pour le gradient des optimiseurs `"adadelta"` et `"rmsprop"`. Ignoré pour les autres optimiseurs. Valeurs valides : valeur à virgule flottante, plage : [`0.0`, `1.0`]. Valeur par défaut : `0.95`. |
| train\$1only\$1on\$1top\$1layer | S'il a pour valeur `"True"`, seuls les paramètres de la couche de classification supérieure sont ajustés. S'il a pour valeur `"False"`, tous les paramètres du modèle sont affinés. Valeurs valides : chaîne, valeur : (`"True"` ou `"False"`). Valeur par défaut : `"False"`. |
# Régler la détection d'un objet - TensorFlow modèle
Le *réglage de modèle automatique*, ou réglage d'hyperparamètre, détecte la meilleure version d'un modèle en exécutant plusieurs tâches qui testent une plage d'hyperparamètres sur votre jeu de données. Vous choisissez les hyperparamètres réglables, une plage de valeurs pour chacun d'eux et une métrique d'objectif. Vous choisissez la métrique d'objectif parmi les métriques que calcule l'algorithme. Le réglage de modèle automatique recherche parmi les hyperparamètres choisis la combinaison de valeurs qui produira un modèle permettant d'optimiser la métrique d'objectif.
Pour plus d'informations sur le réglage de modèle, consultez [Réglage automatique du modèle grâce à l' SageMaker IA](automatic-model-tuning.md).
## Métriques calculées par l' TensorFlow algorithme de détection d'objets
Reportez-vous au tableau suivant pour savoir quelles mesures sont calculées par l' TensorFlow algorithme de détection d'objets.
| Nom de la métrique | Description | Orientation de l'optimisation | Motif Regex |
| --- | --- | --- | --- |
| validation:localization\$1loss | La perte de localisation pour la prédiction des boîtes. | Réduire | `Val_localization=([0-9\\.]+)` |
## Détection d'objets réglable - hyperparamètres TensorFlow
Personnalisez un modèle de détection d'objet avec les hyperparamètres suivants. Les hyperparamètres qui ont le plus d'impact sur la métrique d'objectif de détection d'objet sont : `batch_size`, `learning_rate` et `optimizer`. Réglez les hyperparamètres associés à l'optimiseur, tels que `momentum`, `regularizers_l2`, `beta_1`, `beta_2` et `eps`, en fonction de l'`optimizer` sélectionné. Par exemple, utilisez `beta_1` et `beta_2` uniquement si `adam` = `optimizer`.
Pour plus d'informations sur les hyperparamètres qui sont utilisés pour chaque `optimizer`, consultez [Détection d'objets - TensorFlow Hyperparamètres](object-detection-tensorflow-Hyperparameter.md).
| Nom du paramètre | Type de paramètre | Plages recommandées |
| --- | --- | --- |
| batch\$1size | IntegerParameterRanges | MinValue: 8, MaxValue 512 |
| beta\$11 | ContinuousParameterRanges | MinValue: 1e-6, 0,99 MaxValue |
| beta\$12 | ContinuousParameterRanges | MinValue: 1e-6, 0,99 MaxValue |
| eps | ContinuousParameterRanges | MinValue: 1e-8, MaxValue : 1,0 |
| learning\$1rate | ContinuousParameterRanges | MinValue: 1e-6, 0,5 MaxValue |
| momentum | ContinuousParameterRanges | MinValue: 0,0, MaxValue 0,99 |
| 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 |