As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Detecção de objetos - TensorFlow
<a name="object-detection-tensorflow"></a>

O algoritmo Amazon SageMaker AI Object Detection é um TensorFlow algoritmo de aprendizado supervisionado que oferece suporte ao aprendizado por transferência com muitos modelos pré-treinados do [TensorFlow Model](https://github.com/tensorflow/models) Garden. Use transferir aprendizado para ajustar um dos modelos pré-treinados disponíveis em seu próprio conjunto de dados, mesmo que uma grande quantidade de dados de imagem não esteja disponível. O algoritmo de detecção de objetos usa uma imagem como entrada e gera uma lista de caixas delimitadoras. Os conjuntos de dados de treinamento devem consistir em imagens no formato `jpg`, `.jpeg` ou `.png`. Esta página inclui informações sobre recomendações de instâncias do Amazon EC2 e exemplos de notebooks para detecção de objetos -. TensorFlow

**Topics**
+ [Como usar o TensorFlow algoritmo de detecção de objetos com SageMaker IA](object-detection-tensorflow-how-to-use.md)
+ [Interface de entrada e saída para o TensorFlow algoritmo de detecção de objetos](object-detection-tensorflow-inputoutput.md)
+ [Recomendação de instância do Amazon EC2 para o algoritmo de detecção de objetos TensorFlow](#object-detection-tensorflow-instances)
+ [Detecção de objetos - TensorFlow exemplos de cadernos](#object-detection-tensorflow-sample-notebooks)
+ [Como TensorFlow funciona a detecção de objetos](object-detection-tensorflow-HowItWorks.md)
+ [TensorFlow Modelos](object-detection-tensorflow-Models.md)
+ [Detecção de objetos - TensorFlow Hiperparâmetros](object-detection-tensorflow-Hyperparameter.md)
+ [Ajuste a detecção de objetos - TensorFlow modelo](object-detection-tensorflow-tuning.md)

# Como usar o TensorFlow algoritmo de detecção de objetos com SageMaker IA
<a name="object-detection-tensorflow-how-to-use"></a>

Você pode usar a Detecção de objetos - TensorFlow como um algoritmo integrado de SageMaker IA da Amazon. A seção a seguir descreve como usar a Detecção de objetos TensorFlow com o SageMaker SDK AI Python. Para obter informações sobre como usar a Detecção de objetos, na interface TensorFlow do usuário do Amazon SageMaker Studio Classic, consulte[SageMaker JumpStart modelos pré-treinados](studio-jumpstart.md).

O TensorFlow algoritmo de detecção de objetos suporta o aprendizado por transferência usando qualquer um dos TensorFlow modelos pré-treinados compatíveis. Para obter uma lista de todos os modelos pré-treinados disponíveis, consulte [TensorFlow Modelos](object-detection-tensorflow-Models.md). Cada modelo pré-treinado tem um `model_id` exclusivo. O exemplo a seguir usa ResNet 50 (`model_id`:`tensorflow-od1-ssd-resnet50-v1-fpn-640x640-coco17-tpu-8`) para ajustar um conjunto de dados personalizado. Os modelos pré-treinados são todos pré-baixados do TensorFlow Hub e armazenados em buckets do Amazon S3 para que os trabalhos de treinamento possam ser executados isoladamente na rede. Use esses artefatos de treinamento de modelos pré-gerados para criar um estimador de SageMaker IA.

Primeiro, recupere o URI da imagem do Docker, o URI do script de treinamento e o URI do modelo pré-treinado. Em seguida, altere os hiperparâmetros conforme desejar. Você pode ver um dicionário Python de todos os hiperparâmetros disponíveis e seus valores padrão com `hyperparameters.retrieve_default`. Para obter mais informações, consulte [Detecção de objetos - TensorFlow Hiperparâmetros](object-detection-tensorflow-Hyperparameter.md). Use esses valores para criar um estimador de SageMaker IA.

**nota**  
Os valores padrão dos hiperparâmetros são diferentes para modelos diferentes. Por exemplo, para modelos maiores, o número de epochs padrão do lote é menor. 

Este exemplo usa o conjunto de dados [https://www.cis.upenn.edu/~jshi/ped_html/#pub1](https://www.cis.upenn.edu/~jshi/ped_html/#pub1), que contém imagens de pedestres na rua. Nós pré-baixamos o conjunto de dados e o disponibilizamos com o Amazon S3. Para ajustar seu modelo, chame `.fit` usando a localização do Amazon S3 do seu conjunto de dados de treinamento.

```
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 obter mais informações sobre como usar o TensorFlow algoritmo SageMaker AI Object Detection para transferir o aprendizado em um conjunto de dados personalizado, consulte o caderno [Introdução à SageMaker TensorFlow Detecção de Objetos](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/object_detection_tensorflow/Amazon_Tensorflow_Object_Detection.ipynb).

# Interface de entrada e saída para o TensorFlow algoritmo de detecção de objetos
<a name="object-detection-tensorflow-inputoutput"></a>

Cada um dos modelos pré-treinados listados em TensorFlow Modelos pode ser ajustado a qualquer conjunto de dados com qualquer número de classes de imagem. Lembre-se de como formatar seus dados de treinamento para serem inseridos no TensorFlow modelo de Detecção de Objetos.
+ **Formato de entrada de dados de treinamento:** seus dados de treinamento devem ser um diretório com um subdiretório `images` e um arquivo `annotations.json`. 

Veja a seguir um exemplo de uma estrutura de diretório de entrada. O diretório de entrada deve ser hospedado em um bucket do Amazon S3 com um caminho semelhante ao seguinte: `s3://bucket_name/input_directory/`. Observe que o rastreamento `/` é obrigatório.

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

O arquivo `annotations.json` deve conter informações sobre caixas delimitadoras e seus rótulos de classe na forma de um dicionário `"images"` e chaves `"annotations"`. O valor da chave `"images"` deve ser uma lista de dicionários. Deve haver um dicionário para cada imagem com as seguintes informações: `{"file_name": image_name, "height": height, "width": width, "id": image_id}`. O valor da chave `"annotations"` também deve ser uma lista de dicionários. Deve haver um dicionário para cada caixa delimitadora com as seguintes informações: `{"image_id": image_id, "bbox": [xmin, ymin, xmax, ymax], "category_id": bbox_label}`.

Após o treinamento, um arquivo de mapeamento de rótulos e um modelo treinado são salvos em seu bucket do Amazon S3.

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

Você pode semear o treinamento de um novo modelo com artefatos de um modelo que você treinou anteriormente com SageMaker IA. Um treinamento incremental economiza tempo de treinamento quando você deseja treinar um novo modelo com dados iguais ou semelhantes.

**nota**  
Você só pode semear um modelo de Detecção de Objetos de SageMaker IA com outro TensorFlow modelo de Detecção TensorFlow de Objetos treinado em SageMaker IA. 

Você pode usar qualquer conjunto de dados para treinamento incremental, desde que o conjunto de classes permaneça o mesmo. A etapa de treinamento incremental é semelhante à etapa de ajuste, mas em vez de começar com um modelo pré-treinado, você começa com um modelo já ajustado. Para obter mais informações sobre como usar o treinamento incremental com o SageMaker AI Object Detection - TensorFlow, consulte o caderno [Introdução à SageMaker TensorFlow Detecção de Objetos](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/object_detection_tensorflow/Amazon_Tensorflow_Object_Detection.ipynb).

## Inferência com o algoritmo de detecção de objetos TensorFlow
<a name="object-detection-tensorflow-inference"></a>

Você pode hospedar o modelo ajustado que resulta do seu treinamento de Detecção de TensorFlow Objetos para inferência. Qualquer imagem de entrada para inferência deve estar em formato `.jpg`, .`jpeg`, ou `.png` e deve do ser tipo de conteúdo `application/x-image`. O TensorFlow algoritmo de Detecção de Objetos redimensiona as imagens de entrada automaticamente. 

A execução da inferência resulta em caixas delimitadoras, classes previstas e as pontuações de cada predição codificada no formato JSON. O TensorFlow modelo Detecção de objetos processa uma única imagem por solicitação e gera somente uma linha. Veja a seguir um exemplo de resposta no 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>}
```

Se `accept` estiver definido como `application/json`, o modelo só produzirá caixas, classes e pontuações normalizadas. 

## Recomendação de instância do Amazon EC2 para o algoritmo de detecção de objetos TensorFlow
<a name="object-detection-tensorflow-instances"></a>

O TensorFlow algoritmo de detecção de objetos é compatível com todas as instâncias de GPU para treinamento, incluindo:
+ `ml.p2.xlarge`
+ `ml.p2.16xlarge`
+ `ml.p3.2xlarge`
+ `ml.p3.16xlarge`

Recomendamos o uso de instâncias de GPU com mais memória para treinamento com grandes tamanhos de lote. Tanto as instâncias de CPU (como M5) quanto as de GPU (P2 ou P3) podem ser usadas para inferência. Para obter uma lista abrangente de instâncias de SageMaker treinamento e inferência em todas AWS as regiões, consulte [Amazon SageMaker Pricing](https://aws.amazon.com/sagemaker/pricing/).

## Detecção de objetos - TensorFlow exemplos de cadernos
<a name="object-detection-tensorflow-sample-notebooks"></a>

Para obter mais informações sobre como usar o TensorFlow algoritmo SageMaker AI Object Detection para transferir o aprendizado em um conjunto de dados personalizado, consulte o caderno [Introdução à SageMaker TensorFlow Detecção de Objetos](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/object_detection_tensorflow/Amazon_Tensorflow_Object_Detection.ipynb).

Para obter instruções sobre como criar e acessar instâncias do notebook Jupyter que você pode usar para executar o exemplo em SageMaker IA, consulte. [Instâncias de SageMaker notebook da Amazon](nbi.md) Depois de criar uma instância do notebook e abri-la, selecione a guia **Exemplos de SageMaker IA** para ver uma lista de todas as amostras de SageMaker IA. Para abrir um caderno, escolha a guia **Uso** e depois escolha **Criar cópia**.

# Como TensorFlow funciona a detecção de objetos
<a name="object-detection-tensorflow-HowItWorks"></a>

O TensorFlow algoritmo de Detecção de Objetos usa uma imagem como entrada e prevê caixas delimitadoras e rótulos de objetos. Várias redes de aprendizado profundo MobileNet, como, ResNet, Inception e, EfficientNet são altamente precisas para detecção de objetos. Também existem redes de aprendizado profundo que são treinadas em grandes conjuntos de dados de imagens, como Common Objects in Context (COCO), que tem 328.000 imagens. Depois que uma rede é treinada com dados do COCO, você pode então ajustar a rede em um conjunto de dados com um foco específico para realizar tarefas de detecção de objetos mais específicas. O TensorFlow algoritmo Amazon SageMaker AI Object Detection suporta o aprendizado por transferência em muitos modelos pré-treinados que estão disponíveis no TensorFlow Model Garden.

De acordo com o número de rótulos de classe em seus dados de treinamento, uma camada de detecção de objetos é anexada ao TensorFlow modelo pré-treinado de sua escolha. Você pode, então, ajustar toda a rede (incluindo o modelo pré-treinado) ou somente a camada de classificação superior nos novos dados de treinamento. Com esse método de transferência de aprendizado, é possível treinar com conjuntos de dados menores.

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

Os seguintes modelos pré-treinados estão disponíveis para uso no aprendizado por transferência com o TensorFlow algoritmo de Detecção de Objetos. 

Os modelos a seguir variam significativamente em tamanho, número de parâmetros do modelo, tempo de treinamento e latência de inferência para qualquer conjunto de dados. O melhor modelo para seu caso de uso depende da complexidade do seu conjunto de dados de ajuste fino e de quaisquer requisitos que você tenha sobre tempo de treinamento, latência de inferência ou precisão do modelo.


| Nome do modelo | `model_id` | Fonte | 
| --- | --- | --- | 
| ResNet50 V1 VPN 640 | `tensorflow-od1-ssd-resnet50-v1-fpn-640x640-coco17-tpu-8` | [TensorFlow Link do Model Garden](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 Link do 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 Link do 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 Link do Model Garden](http://download.tensorflow.org/models/object_detection/tf2/20200711/efficientdet_d2_coco17_tpu-32.tar.gz) | 
| EfficientDet 3D 896 | `tensorflow-od1-ssd-efficientdet-d3-896x896-coco17-tpu-32` | [TensorFlow Link do Model Garden](http://download.tensorflow.org/models/object_detection/tf2/20200711/efficientdet_d3_coco17_tpu-32.tar.gz) | 
| MobileNet VPN V1 640 | `tensorflow-od1-ssd-mobilenet-v1-fpn-640x640-coco17-tpu-8` | [TensorFlow Link do Model Garden](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_mobilenet_v1_fpn_640x640_coco17_tpu-8.tar.gz) | 
| MobileNet V2 320 FPNLite  | `tensorflow-od1-ssd-mobilenet-v2-fpnlite-320x320-coco17-tpu-8` | [TensorFlow Link do Model Garden](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_mobilenet_v2_fpnlite_320x320_coco17_tpu-8.tar.gz) | 
| MobileNet V2 640 FPNLite  | `tensorflow-od1-ssd-mobilenet-v2-fpnlite-640x640-coco17-tpu-8` | [TensorFlow Link do Model Garden](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 Link do Model Garden](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_resnet50_v1_fpn_1024x1024_coco17_tpu-8.tar.gz) | 
| ResNet101 V1 VPN 640 | `tensorflow-od1-ssd-resnet101-v1-fpn-640x640-coco17-tpu-8` | [TensorFlow Link do Model Garden](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_resnet101_v1_fpn_640x640_coco17_tpu-8.tar.gz) | 
| ResNet101 V1 VPN 1024 | `tensorflow-od1-ssd-resnet101-v1-fpn-1024x1024-coco17-tpu-8` | [TensorFlow Link do Model Garden](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_resnet101_v1_fpn_1024x1024_coco17_tpu-8.tar.gz) | 
| ResNet152 V1 VPN 640 | `tensorflow-od1-ssd-resnet152-v1-fpn-640x640-coco17-tpu-8` | [TensorFlow Link do Model Garden](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_resnet152_v1_fpn_640x640_coco17_tpu-8.tar.gz) | 
| ResNet152 V1 VPN 1024 | `tensorflow-od1-ssd-resnet152-v1-fpn-1024x1024-coco17-tpu-8` | [TensorFlow Link do Model Garden](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_resnet152_v1_fpn_1024x1024_coco17_tpu-8.tar.gz) | 

# Detecção de objetos - TensorFlow Hiperparâmetros
<a name="object-detection-tensorflow-Hyperparameter"></a>

Hiperparâmetros são parâmetros definidos antes de um modelo de machine learning começar a aprender. Os hiperparâmetros a seguir são compatíveis com o TensorFlow algoritmo de detecção de objetos incorporado ao Amazon SageMaker AI. Para obter informações sobre ajuste de hiperparâmetros, consulte [Ajuste a detecção de objetos - TensorFlow modelo](object-detection-tensorflow-tuning.md). 


| Nome do parâmetro | Description | 
| --- | --- | 
| batch\$1size |  O tamanho do lote para treinamento.  Valores válidos: inteiro positivo. Valor padrão: `3`.  | 
| beta\$11 |  O beta1 para o otimizador `"adam"`. Representa a taxa de degradação exponencial para as estimativas de primeiro momento. Ignorado por outros otimizadores. Valores válidos: flutuante, intervalo: [`0.0`, `1.0`]. Valor padrão: `0.9`.  | 
| beta\$12 |  O beta2 para o otimizador `"adam"`. Representa a taxa de degradação exponencial para as estimativas de segundo momento. Ignorado por outros otimizadores. Valores válidos: flutuante, intervalo: [`0.0`, `1.0`]. Valor padrão: `0.999`.  | 
| early\$1stopping |  Defina para `"True"` para usar a lógica de interrupção precoce durante o treinamento. Se `"False"`, a interrupção antecipada não é usada. Valores válidos: string, ou: (`"True"` ou `"False"`). Valor padrão: `"False"`.  | 
| early\$1stopping\$1min\$1delta | A alteração mínima necessária para se qualificar como uma melhoria. Uma mudança absoluta menor que o valor de early\$1stopping\$1min\$1delta não se qualifica como melhoria. Usado somente quando early\$1stopping for definido como "True".Valores válidos: flutuante, intervalo: [`0.0`, `1.0`].Valor padrão: `0.0`. | 
| early\$1stopping\$1patience |  O número de épocas para continuar treinando sem melhorias. Usado somente quando `early_stopping` for definido como `"True"`. Valores válidos: inteiro positivo. Valor padrão: `5`.  | 
| epochs |  O número de epochs de treinamento. Valores válidos: inteiro positivo. Valor padrão: `5` para modelos menores, `1` para modelos maiores.  | 
| epsilon |  O épsilon para os otimizadores `"adam"`, `"rmsprop"`, `"adadelta"` e `"adagrad"`. Geralmente é definido como um valor baixo, para evitar a divisão por 0. Ignorado por outros otimizadores. Valores válidos: flutuante, intervalo: [`0.0`, `1.0`]. Valor padrão: `1e-7`.  | 
| initial\$1accumulator\$1value |  O valor inicial para os acumuladores, ou os valores de momentum por parâmetro, para o otimizador `"adagrad"`. Ignorado por outros otimizadores. Valores válidos: flutuante, intervalo: [`0.0`, `1.0`]. Valor padrão: `0.1`.  | 
| learning\$1rate | A taxa de aprendizado do otimizador. Valores válidos: flutuante, intervalo: [`0.0`, `1.0`].Valor padrão: `0.001`. | 
| momentum |  A dinâmica dos otimizadores `"sgd"` e `"nesterov"`. Ignorado por outros otimizadores. Valores válidos: flutuante, intervalo: [`0.0`, `1.0`]. Valor padrão: `0.9`.  | 
| optimizer |  O tipo de otimizador. Para obter mais informações, consulte [Otimizadores](https://www.tensorflow.org/api_docs/python/tf/keras/optimizers) na TensorFlow documentação. Valores válidos: string, qualquer um dos seguintes: (`"adam"`, `"sgd"`, `"nesterov"`, `"rmsprop"`, ` "adagrad"` ou `"adadelta"`). Valor padrão: `"adam"`.  | 
| reinitialize\$1top\$1layer |  Se definido como `"Auto"`, os parâmetros da camada de classificação superior são reinicializados durante o ajuste fino. Para treinamento incremental, os parâmetros da camada de classificação superior não são reinicializados, a menos que sejam definidos como `"True"`. Valores válidos: string, qualquer um dos seguintes: (`"Auto"`, `"True"` ou `"False"`). Valor padrão: `"Auto"`.  | 
| rho |  O fator de desconto para o gradiente dos otimizadores `"adadelta"` e `"rmsprop"`. Ignorado por outros otimizadores.  Valores válidos: flutuante, intervalo: [`0.0`, `1.0`]. Valor padrão: `0.95`.  | 
| train\$1only\$1on\$1top\$1layer |  Se `"True"`, somente os parâmetros da camada de classificação superior forem ajustados. Se `"False"`, todos os parâmetros do modelo são ajustados. Valores válidos: string, ou: (`"True"` ou `"False"`). Valor padrão: `"False"`.  | 

# Ajuste a detecção de objetos - TensorFlow modelo
<a name="object-detection-tensorflow-tuning"></a>

O *ajuste automático de modelos*, também conhecido como ajuste de hiperparâmetros, localiza a melhor versão de um modelo executando vários trabalhos que testam uma série de hiperparâmetros no seu conjunto de dados. Você escolhe os hiperparâmetros ajustáveis, um intervalo de valores para cada um e uma métrica objetiva. Você escolhe a métrica objetiva entre as métricas que o algoritmo calcula. O ajuste de modelo automático pesquisa os hiperparâmetros escolhidos para encontrar a combinação de valores que resultam no modelo que otimiza a métrica objetiva.

Para mais informações sobre o ajuste de modelos, consulte [Ajuste automático do modelo com SageMaker IA](automatic-model-tuning.md).

## Métricas calculadas pelo algoritmo de detecção de objetos TensorFlow
<a name="object-detection-tensorflow-metrics"></a>

Consulte a tabela a seguir para descobrir quais métricas são calculadas pelo TensorFlow algoritmo de Detecção de Objetos.


| Nome da métrica | Description | Direção de otimização | Padrão Regex | 
| --- | --- | --- | --- | 
| validation:localization\$1loss | A perda de localização para predição de caixa. | Minimizar | `Val_localization=([0-9\\.]+)` | 

## Detecção de objetos ajustável - hiperparâmetros TensorFlow
<a name="object-detection-tensorflow-tunable-hyperparameters"></a>

Ajuste um modelo de detecção de objetos do com os seguintes hiperparâmetros: Os hiperparâmetros que têm o maior impacto sobre métrica objetiva de detecção de objetos são: `batch_size`, `learning_rate` e `optimizer`. Ajuste os hiperparâmetros relacionados com o otimizador, como `momentum`, `regularizers_l2`, `beta_1`, `beta_2` e `eps` com base no `optimizer` selecionado. Por exemplo, use `beta_1` e `beta_2` somente quando `adam` for o `optimizer`.

Para obter mais informações sobre quais hiperparâmetros são usados para cada `optimizer`, consulte [Detecção de objetos - TensorFlow Hiperparâmetros](object-detection-tensorflow-Hyperparameter.md).


| Nome do parâmetro | Tipo de parâmetro | Intervalos recomendados | 
| --- | --- | --- | 
| 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 |