Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Detección de objetos - TensorFlow
<a name="object-detection-tensorflow"></a>

El algoritmo Amazon SageMaker AI Object Detection es un TensorFlow algoritmo de aprendizaje supervisado que admite el aprendizaje por transferencia con muchos modelos previamente entrenados del [TensorFlow Model Garden](https://github.com/tensorflow/models). Utilice el aprendizaje por transferencia para ajustar uno de los modelos previamente entrenados disponibles en su propio conjunto de datos, aunque no haya una gran cantidad de datos de imagen disponibles. El algoritmo de detección de objetos toma una imagen como entrada y genera una lista de casillas delimitadoras. Los conjuntos de datos de entrenamiento deben estar compuestos por imágenes en formato `jpg`, `.jpeg` o `.png`. Esta página incluye información sobre las recomendaciones de instancias de Amazon EC2 y cuadernos de muestra para Object Detection -. TensorFlow

**Topics**
+ [Cómo utilizar el algoritmo de detección de objetos mediante SageMaker IA TensorFlow](object-detection-tensorflow-how-to-use.md)
+ [Interfaz de entrada y salida para el TensorFlow algoritmo de detección de objetos](object-detection-tensorflow-inputoutput.md)
+ [Recomendación de instancia de Amazon EC2 para el algoritmo de detección de objetos TensorFlow](#object-detection-tensorflow-instances)
+ [Detección de objetos: TensorFlow ejemplos de cuadernos](#object-detection-tensorflow-sample-notebooks)
+ [Cómo TensorFlow funciona la detección de objetos](object-detection-tensorflow-HowItWorks.md)
+ [TensorFlow Modelos](object-detection-tensorflow-Models.md)
+ [Detección de objetos: TensorFlow hiperparámetros](object-detection-tensorflow-Hyperparameter.md)
+ [Ajuste un modelo de detección de objetos TensorFlow](object-detection-tensorflow-tuning.md)

# Cómo utilizar el algoritmo de detección de objetos mediante SageMaker IA TensorFlow
<a name="object-detection-tensorflow-how-to-use"></a>

Puede utilizar la detección de objetos, TensorFlow como un algoritmo integrado de Amazon SageMaker AI. En la siguiente sección, se describe cómo utilizar la detección de objetos TensorFlow con el SDK de Python para SageMaker IA. Para obtener información sobre cómo utilizar la detección de objetos, TensorFlow desde la interfaz de usuario clásica de Amazon SageMaker Studio, consulte[SageMaker JumpStart modelos preentrenados](studio-jumpstart.md).

El TensorFlow algoritmo de detección de objetos admite el aprendizaje por transferencia mediante cualquiera de los TensorFlow modelos preentrenados compatibles. Para obtener una lista de todos los modelos prentrenados disponibles, consulte [TensorFlow Modelos](object-detection-tensorflow-Models.md). Cada modelo prentrenado tiene un `model_id` de modelo único. En el siguiente ejemplo, se utiliza ResNet 50 (`model_id`:`tensorflow-od1-ssd-resnet50-v1-fpn-640x640-coco17-tpu-8`) para ajustar con precisión un conjunto de datos personalizado. Todos los modelos previamente entrenados se descargan previamente del TensorFlow Hub y se almacenan en buckets de Amazon S3 para que los trabajos de capacitación se puedan ejecutar de forma aislada en la red. Utilice estos artefactos de entrenamiento de modelos pregenerados para construir un estimador de IA. SageMaker 

En primer lugar, recupere el URI de la imagen de Docker, del script de entrenamiento y del modelo prentrenado. Luego, cambie los hiperparámetros como crea conveniente. Puede ver un diccionario de Python con todos los hiperparámetros disponibles y sus valores predeterminados con `hyperparameters.retrieve_default`. Para obtener más información, consulte [Detección de objetos: TensorFlow hiperparámetros](object-detection-tensorflow-Hyperparameter.md). Usa estos valores para construir un SageMaker estimador de IA.

**nota**  
Los valores de hiperparámetros predeterminados son diferentes para los distintos modelos. Por ejemplo, para los modelos más grandes, el número predeterminado de epochs (fechas de inicio) es menor. 

En este ejemplo, se utiliza el conjunto de datos [https://www.cis.upenn.edu/~jshi/ped_html/#pub1](https://www.cis.upenn.edu/~jshi/ped_html/#pub1), que contiene imágenes de peatones en la calle. Hemos descargado previamente el conjunto de datos y hemos hecho que esté disponible en Amazon S3. Para ajustar su modelo, llame a `.fit` utilizando la ubicación de Amazon S3 del conjunto de datos de entrenamiento.

```
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)
```

Para obtener más información sobre cómo utilizar el TensorFlow algoritmo de detección de objetos mediante SageMaker IA para transferir el aprendizaje a un conjunto de datos personalizado, consulte el cuaderno [Introducción a SageMaker TensorFlow la detección de objetos](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/object_detection_tensorflow/Amazon_Tensorflow_Object_Detection.ipynb).

# Interfaz de entrada y salida para el TensorFlow algoritmo de detección de objetos
<a name="object-detection-tensorflow-inputoutput"></a>

Cada uno de los modelos previamente entrenados que figuran en TensorFlow Modelos se puede ajustar a cualquier conjunto de datos con cualquier número de clases de imágenes. Ten cuidado con el formato de los datos de entrenamiento para introducirlos en el modelo de detección de objetos. TensorFlow 
+ **Formato de entrada de los datos de entrenamiento:** los datos de entrenamiento deben estar en un directorio con un subdirectorio `images` y un archivo `annotations.json`. 

A continuación se muestra un ejemplo con una estructura de directorios de entrada. El directorio de entrada debe alojarse en un bucket de Amazon S3 con una ruta similar a `s3://bucket_name/input_directory/`. Tenga en cuenta que es obligatorio incluir `/` al final.

```
input_directory
    |--images
        |--abc.png
        |--def.png
    |--annotations.json
```

El archivo `annotations.json` debe contener información sobre los cuadros delimitadores y sus etiquetas de clase en forma de diccionario `"images"` y claves de `"annotations"`. El valor de la clave `"images"` debe ser una lista de diccionarios. Debe haber un diccionario para cada imagen con la siguiente información: `{"file_name": image_name, "height": height, "width": width, "id": image_id}`. El valor de la clave `"annotations"` debe ser también una lista de diccionarios. Debe haber un diccionario para cada cuadro delimitador con la siguiente información: `{"image_id": image_id, "bbox": [xmin, ymin, xmax, ymax], "category_id": bbox_label}`.

Tras el entrenamiento, se guarda un archivo de asignación de etiquetas y un modelo entrenado en su bucket de Amazon S3.

## Entrenamiento incremental
<a name="object-detection-tensorflow-incremental-training"></a>

Puedes iniciar el entrenamiento de un nuevo modelo con artefactos de un modelo que hayas entrenado previamente con SageMaker IA. El entrenamiento incremental supone un ahorro de tiempo cuando queremos entrenar un nuevo modelo con datos idénticos o similares.

**nota**  
Solo puedes combinar un modelo de detección de objetos mediante SageMaker IA con otro TensorFlow modelo de detección de objetos entrenado en SageMaker IA. TensorFlow 

Para el entrenamiento incremental, puede utilizar cualquier conjunto de datos, siempre y cuando el conjunto de clases siga siendo el mismo. El paso de entrenamiento incremental es similar al paso de ajuste; la diferencia es que, en lugar de comenzar con un modelo previamente entrenado, se comienza con un modelo de ajuste fino existente. Para obtener más información sobre cómo utilizar el entrenamiento incremental con la detección de objetos mediante SageMaker IA TensorFlow, consulte el cuaderno [Introducción a SageMaker TensorFlow la detección de objetos](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/object_detection_tensorflow/Amazon_Tensorflow_Object_Detection.ipynb).

## Inferencia con el algoritmo de detección de objetos TensorFlow
<a name="object-detection-tensorflow-inference"></a>

Puede alojar el modelo ajustado que resulta de su entrenamiento en detección de TensorFlow objetos para realizar inferencias. Cualquier imagen de entrada para la inferencia debe estar en el formato `.jpg`, `jpeg` o `.png` y ser del tipo de contenido `application/x-image`. El TensorFlow algoritmo de detección de objetos cambia el tamaño de las imágenes de entrada automáticamente. 

Al ejecutar la inferencia, se codifican en formato JSON los recuadros delimitadores, las clases pronosticadas y las puntuaciones de cada predicción. El TensorFlow modelo de detección de objetos procesa una sola imagen por solicitud y genera solo una línea. Lo siguiente es un ejemplo de una respuesta en formato 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":<original output of the model>}
```

Si `accept` está configurado en `application/json`, el modelo solo genera cuadros, clases y puntuaciones normalizados. 

## Recomendación de instancia de Amazon EC2 para el algoritmo de detección de objetos TensorFlow
<a name="object-detection-tensorflow-instances"></a>

El TensorFlow algoritmo de detección de objetos es compatible con todas las instancias de GPU para el entrenamiento, incluidas las siguientes:
+ `ml.p2.xlarge`
+ `ml.p2.16xlarge`
+ `ml.p3.2xlarge`
+ `ml.p3.16xlarge`

Para el entrenamiento con lotes grandes, recomendamos utilizar instancias de GPU con más memoria. Para la inferencia, se pueden usar instancias de CPU (como M5) o de GPU (P2 o P3). Para obtener una lista completa de instancias de SageMaker formación e inferencia en todas AWS las regiones, consulta [Amazon SageMaker Pricing](https://aws.amazon.com/sagemaker/pricing/).

## Detección de objetos: TensorFlow ejemplos de cuadernos
<a name="object-detection-tensorflow-sample-notebooks"></a>

Para obtener más información sobre cómo utilizar el TensorFlow algoritmo de detección de objetos mediante SageMaker IA para transferir el aprendizaje en un conjunto de datos personalizado, consulte la [introducción al SageMaker TensorFlow cuaderno de detección de objetos](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/object_detection_tensorflow/Amazon_Tensorflow_Object_Detection.ipynb).

Para obtener instrucciones sobre cómo crear instancias de Jupyter Notebook y acceder a ellas, que puede utilizar para ejecutar el ejemplo en SageMaker IA, consulte. [Instancias de Amazon SageMaker Notebook](nbi.md) Una vez que haya creado una instancia de bloc de notas y la haya abierto, seleccione la pestaña **Ejemplos de SageMaker IA** para ver una lista de todos los ejemplos de SageMaker IA. Para abrir un cuaderno, elija su pestaña **Usar** y elija **Crear copia**.

# Cómo TensorFlow funciona la detección de objetos
<a name="object-detection-tensorflow-HowItWorks"></a>

El TensorFlow algoritmo de detección de objetos toma una imagen como entrada y predice los cuadros delimitadores y las etiquetas de los objetos. Varias redes de aprendizaje profundo MobileNet, como Inception ResNet, EfficientNet son muy precisas para la detección de objetos. También hay redes de aprendizaje profundo que se entrenan con conjuntos de datos de imágenes de gran tamaño, como Common Objects in Context (COCO), que tiene 328 000 imágenes. Tras entrenar una red con datos de COCO, puede ajustarla en un conjunto de datos, con el objetivo principal de llevar a cabo tareas de detección de objetos más específicas. El TensorFlow algoritmo Amazon SageMaker AI Object Detection admite el aprendizaje por transferencia en muchos modelos previamente entrenados que están disponibles en el TensorFlow Model Garden.

Según el número de etiquetas de clase que figuren en tus datos de entrenamiento, se adjunta una capa de detección de objetos al TensorFlow modelo previamente entrenado que elijas. Luego, puede ajustar toda la red (lo que incluye el modelo prentrenado) o solo la capa de clasificación superior en los nuevos datos de entrenamiento. Con este método de aprendizaje por transferencia, es posible llevar a cabo el entrenamiento con conjuntos de datos más pequeños.

# TensorFlow Modelos
<a name="object-detection-tensorflow-Models"></a>

Los siguientes modelos previamente entrenados están disponibles para su uso en el aprendizaje por transferencia con el TensorFlow algoritmo de detección de objetos. 

El tamaño, la cantidad de parámetros, el tiempo de entrenamiento y la latencia de inferencia de estos modelos puede variar considerablemente para un conjunto de datos determinado. El mejor modelo para su caso de uso dependerá de la complejidad del conjunto de datos de ajuste y de sus necesidades con respecto al tiempo de entrenamiento, la latencia de inferencia o la precisión del modelo.


| Nombre del modelo | `model_id` | origen | 
| --- | --- | --- | 
| 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 Enlace a Model Garden](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 Enlace a Model Garden](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 Enlace a Model Garden](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 Enlace a Model Garden](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 Enlace a Model Garden](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 Enlace a Model Garden](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 Enlace a Model Garden](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 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) | 

# Detección de objetos: TensorFlow hiperparámetros
<a name="object-detection-tensorflow-Hyperparameter"></a>

Los hiperparámetros son parámetros que se establecen antes de que un modelo de machine learning comience a aprender. Los siguientes hiperparámetros son compatibles con el TensorFlow algoritmo integrado de detección de objetos de Amazon SageMaker AI. Para obtener más información sobre el ajuste de hiperparámetros, consulte [Ajuste un modelo de detección de objetos TensorFlow](object-detection-tensorflow-tuning.md). 


| Nombre del parámetro | Description (Descripción) | 
| --- | --- | 
| batch\$1size |  El tamaño del lote para la capacitación.  Valores válidos: número entero positivo. Valor predeterminado: `3`.  | 
| beta\$11 |  La versión beta1 del optimizador `"adam"`. Representa la tasa de degradación exponencial para las estimaciones del primer momento. No se tiene en cuenta para otros optimizadores. Valores válidos: flotante, con el rango [`0.0`, `1.0`]. Valor predeterminado: `0.9`.  | 
| beta\$12 |  La versión beta2 del optimizador `"adam"`. Representa la tasa de degradación exponencial para las estimaciones del segundo momento. No se tiene en cuenta para otros optimizadores. Valores válidos: flotante, con el rango [`0.0`, `1.0`]. Valor predeterminado: `0.999`.  | 
| early\$1stopping |  Se establece en `"True"` a fin de usar una lógica de detención temprana durante el entrenamiento. Si es `"False"`, no se utiliza la interrupción temprana. Valores válidos: cadena (`"True"` o `"False"`). Valor predeterminado: `"False"`.  | 
| early\$1stopping\$1min\$1delta | El cambio mínimo necesario para considerarse una mejora. Un cambio absoluto inferior al valor de early\$1stopping\$1min\$1delta no se considera mejora. Solo se usa cuando early\$1stopping está establecido en "True".Valores válidos: flotante, con el rango [`0.0`, `1.0`].Valor predeterminado: `0.0`. | 
| early\$1stopping\$1patience |  El número de epochs (fechas de inicio) para seguir entrenando sin que haya mejoras. Solo se usa cuando `early_stopping` está establecido en `"True"`. Valores válidos: número entero positivo. Valor predeterminado: `5`.  | 
| epochs |  El número de fechas de inicio de capacitación. Valores válidos: número entero positivo. Valor predeterminado: `5` para modelos más pequeños, `1` para modelos más grandes.  | 
| epsilon |  El valor épsilon para los optimizadores `"adam"`, `"rmsprop"`, `"adadelta"` y `"adagrad"`. Se suele establecer en un valor pequeño para evitar la división por 0. No se tiene en cuenta para otros optimizadores. Valores válidos: flotante, con el rango [`0.0`, `1.0`]. Valor predeterminado: `1e-7`.  | 
| initial\$1accumulator\$1value |  El valor inicial de los acumuladores o los valores de impulso por parámetro del optimizador `"adagrad"`. No se tiene en cuenta para otros optimizadores. Valores válidos: flotante, con el rango [`0.0`, `1.0`]. Valor predeterminado: `0.1`.  | 
| learning\$1rate | La tasa de aprendizaje del optimizador. Valores válidos: flotante, con el rango [`0.0`, `1.0`].Valor predeterminado: `0.001`. | 
| momentum |  El valor de impulso para los optimizadores `"sgd"` y `"nesterov"`. No se tiene en cuenta para otros optimizadores. Valores válidos: flotante, con el rango [`0.0`, `1.0`]. Valor predeterminado: `0.9`.  | 
| optimizer |  El tipo de optimizador. Para obtener más información, consulte [Optimizadores](https://www.tensorflow.org/api_docs/python/tf/keras/optimizers) en la TensorFlow documentación. Valores válidos: cadena, (`"adam"`, `"sgd"`, `"nesterov"`, `"rmsprop"`, ` "adagrad"` o `"adadelta"`). Valor predeterminado: `"adam"`.  | 
| reinitialize\$1top\$1layer |  Si se establece en `"Auto"`, los parámetros de la capa de clasificación superior se reinicializan durante el ajuste. Para el entrenamiento incremental, los parámetros de la capa de clasificación superior no se reinicializan, a no ser que se establezca en `"True"`. Valores válidos: cadena, `"Auto"`, `"True"` o `"False"`. Valor predeterminado: `"Auto"`.  | 
| rho |  El factor de descuento para el gradiente de los optimizadores `"adadelta"` y `"rmsprop"`. No se tiene en cuenta para otros optimizadores.  Valores válidos: flotante, con el rango [`0.0`, `1.0`]. Valor predeterminado: `0.95`.  | 
| train\$1only\$1on\$1top\$1layer |  Si es `"True"`, solo se refinan los parámetros de la capa de clasificación superior. Si es `"False"`, todos los parámetros del modelo se refinan. Valores válidos: cadena (`"True"` o `"False"`). Valor predeterminado: `"False"`.  | 

# Ajuste un modelo de detección de objetos TensorFlow
<a name="object-detection-tensorflow-tuning"></a>

El *ajuste de modelo automático*, también conocido como ajuste de hiperparámetros, encuentra la mejor versión de un modelo ejecutando muchas tareas que probar una serie de hiperparámetros en su conjunto de datos. Usted elige los hiperparámetros que pueden ajustarse, un rango de valores para cada uno de ellos y una métrica objetiva. Puede elegir la métrica objetiva de las métricas que el algoritmo computa. El ajuste de modelo automático busca los hiperparámetros elegidos para encontrar la combinación de valores que obtienen el modelo que optimiza la métrica objetiva.

Para obtener más información acerca del ajuste de modelos, consulte [Ajuste automático de modelos con IA SageMaker](automatic-model-tuning.md).

## Métricas calculadas por el algoritmo de detección de objetos TensorFlow
<a name="object-detection-tensorflow-metrics"></a>

Consulte la siguiente tabla para ver qué métricas calcula el TensorFlow algoritmo de detección de objetos.


| Nombre de métrica | Description (Descripción) | Dirección de optimización | Patrón de expresiones regulares | 
| --- | --- | --- | --- | 
| validation:localization\$1loss | La pérdida de localización para la predicción de cuadros. | Minimizar | `Val_localization=([0-9\\.]+)` | 

## Detección de objetos ajustable: hiperparámetros TensorFlow
<a name="object-detection-tensorflow-tunable-hyperparameters"></a>

Ajuste el modelo de detección de objetos con los siguientes hiperparámetros. Los hiperparámetros que tienen el mayor impacto sobre las métricas objetivo de detección de objetos son `batch_size`, `learning_rate` y `optimizer`. Ajuste los hiperparámetros relacionados con el optimizador, como `momentum`, `regularizers_l2`, `beta_1`, `beta_2` y `eps`, en función del `optimizer` seleccionado. Por ejemplo, utilice `beta_1` y `beta_2` solo cuando `adam` es el `optimizer`.

Para obtener más información sobre los hiperparámetros que se utilizan en cada `optimizer`, consulte [Detección de objetos: TensorFlow hiperparámetros](object-detection-tensorflow-Hyperparameter.md).


| Nombre del parámetro | Tipo de parámetro | Intervalos recomendados | 
| --- | --- | --- | 
| batch\$1size | IntegerParameterRanges | MinValue: 8, MaxValue: 512 | 
| beta\$11 | ContinuousParameterRanges | MinValue: 1e-6, 0,999 MaxValue | 
| 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,999 MaxValue | 
| optimizer | CategoricalParameterRanges | ['sgd', ‘adam’, ‘rmsprop’, 'nesterov', 'adagrad', 'adadelta'] | 
| regularizers\$1l2 | ContinuousParameterRanges | MinValue: 0,0, MaxValue 0,999 | 
| train\$1only\$1on\$1top\$1layer | CategoricalParameterRanges | ['True', 'False'] | 
| initial\$1accumulator\$1value | CategoricalParameterRanges | MinValue: 0,0, MaxValue 0,999 |