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á.
# Como criar conjuntos de dados de treinamento e teste com imagens
É possível iniciar com um projeto que tenha um único conjunto de dados ou um projeto que tenha conjuntos de dados de treinamento e teste separados. Se você começar com um único conjunto de dados, o Amazon Rekognition Custom Labels divide seu conjunto de dados durante o treinamento para criar um conjunto de dados de treinamento (80%) e um conjunto de dados de teste (20%) para seu projeto. Comece com um único conjunto de dados se quiser que o Amazon Rekognition Custom Labels decida onde as imagens serão usadas para treinamento e teste. Para ter controle total sobre o treinamento, teste e ajuste de desempenho, recomendamos que você inicie seu projeto com os conjuntos de dados de treinamento e teste separados.
É possível criar conjuntos de dados de treinamento e teste para um projeto importando imagens de um dos seguintes locais:
+ [Importar imagens de um bucket do Amazon S3](md-create-dataset-s3.md)
+ [Importar imagens de um computador local](md-create-dataset-computer.md)
+ [Usar um arquivo de manifesto para importar imagens](md-create-dataset-ground-truth.md)
+ [Copiar conteúdo de um conjunto de dados existente](md-create-dataset-existing-dataset.md)
Se iniciar seu projeto com conjuntos de dados de treinamento e teste separados, poderá usar locais de origem diferentes para cada conjunto de dados.
Dependendo de onde você importa suas imagens, elas podem não estar rotuladas. Por exemplo, imagens importadas de um computador local não estão rotuladas. As imagens importadas de um arquivo de manifesto do Amazon SageMaker AI Ground Truth são rotuladas. É possível usar o console do Amazon Rekognition Custom Labels para adicionar, alterar e atribuir rótulos. Para obter mais informações, consulte [Rotulagem de imagens](md-labeling-images.md).
Se as imagens estiverem sendo carregadas com erros, se faltarem imagens ou se faltarem rótulos nas imagens, leia [Como depurar um treinamento de modelo em falha](tm-debugging.md).
Para obter mais informações sobre conjuntos de dados, consulte [Como gerenciar conjuntos de dados](managing-dataset.md).
## Crie conjuntos de dados de treinamento e teste (SDK)
Você pode usar o AWS SDK para criar conjuntos de dados de treinamento e teste.
A operação `CreateDataset` permite que você opte por especificar etiquetas ao criar um conjunto de dados, com o objetivo de categorizar e gerenciar seus recursos.
### Conjunto de dados de trenaimento
Você pode usar o AWS SDK para criar um conjunto de dados de treinamento das seguintes formas.
+ Use [CreateDataset](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateDataset)com um arquivo de manifesto no formato Amazon Sagemaker fornecido por você. Para obter mais informações, consulte [Criar um arquivo de manifesto](md-create-manifest-file.md). Para obter um código de exemplo, consulte [Criação de um conjunto de dados com um arquivo de manifesto (SDK) do SageMaker AI Ground Truth](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk).
+ Use `CreateDataset` para copiar um conjunto de dados existente do Amazon Rekognition Custom Labels. Para obter um código de exemplo, consulte [Como criar um conjunto de dados usando um conjunto de dados existente (SDK)](md-create-dataset-existing-dataset-sdk.md).
+ Crie um conjunto de dados vazio com `CreateDataset` e adicione entradas do conjunto de dados posteriormente com [UpdateDatasetEntries](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_UpdateDatasetEntries). Para criar um conjunto de dados vazio, consulte [Como adicionar um conjunto de dados a um projeto](md-add-dataset.md). Para adicionar imagens a um conjunto de dados, consulte [Como adicionar mais imagens (SDK)](md-add-images.md#md-add-images-sdk). É necessário adicionar as entradas do conjunto de dados antes de treinar um modelo.
### Conjunto de dados de teste
Você pode usar o AWS SDK para criar um conjunto de dados de teste das seguintes formas:
+ Use [CreateDataset](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateDataset)com um arquivo de manifesto no formato Amazon Sagemaker fornecido por você. Para obter mais informações, consulte [Criar um arquivo de manifesto](md-create-manifest-file.md). Para obter um código de exemplo, consulte [Criação de um conjunto de dados com um arquivo de manifesto (SDK) do SageMaker AI Ground Truth](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk).
+ Use `CreateDataset` para copiar um conjunto de dados existente do Amazon Rekognition Custom Labels. Para obter um código de exemplo, consulte [Como criar um conjunto de dados usando um conjunto de dados existente (SDK)](md-create-dataset-existing-dataset-sdk.md).
+ Crie um conjunto de dados vazio com `CreateDataset` e adicione entradas do conjunto de dados posteriormente com `UpdateDatasetEntries`. Para criar um conjunto de dados vazio, consulte [Como adicionar um conjunto de dados a um projeto](md-add-dataset.md). Para adicionar imagens a um conjunto de dados, consulte [Como adicionar mais imagens (SDK)](md-add-images.md#md-add-images-sdk). É necessário adicionar as entradas do conjunto de dados antes de treinar um modelo.
+ Divida o conjunto de dados de treinamento em conjuntos de dados de treinamento e teste separados. Primeiro, crie um conjunto de dados de teste vazio com `CreateDataset`. Em seguida, mova 20% das entradas do conjunto de dados de treinamento para o conjunto de dados de teste ligando. [DistributeDatasetEntries](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DistributeDatasetEntries) Para criar um conjunto de dados vazio, consulte [Como adicionar um conjunto de dados a um projeto (SDK)](md-add-dataset.md#md-add-dataset-sdk). Para dividir o conjunto de dados de treinamento, consulte [Como distribuir um conjunto de dados de treinamento (SDK)](md-distributing-datasets.md).
# Importar imagens de um bucket do Amazon S3
As imagens são importadas de um bucket do Amazon S3. Você pode usar o bucket do console ou outro bucket do Amazon S3 em sua AWS conta. Se estiver usando o bucket do console, as permissões necessárias já estão configuradas. Se não estiver usando o bucket do console, consulte [Como acessar os buckets externos do Amazon S3](su-console-policy.md#su-external-buckets).
**nota**
Você não pode usar o AWS SDK para criar um conjunto de dados diretamente de imagens em um bucket do Amazon S3. Em vez disso, crie um arquivo de manifesto que faça referência aos locais de origem das imagens. Para obter mais informações, consulte [Usar um arquivo de manifesto para importar imagens](md-create-dataset-ground-truth.md).
Durante a criação do conjunto de dados, é possível escolher atribuir nomes de rótulos às imagens com base no nome da pasta que contém as imagens. As pastas devem ser filhas do caminho da pasta do Amazon S3 especificada na **localização da pasta do S3** durante a criação do conjunto de dados. Para criar um conjunto de dados, consulte [Criação de um conjunto de dados importando imagens de um bucket do S3](#cd-procedure).
Por exemplo, presuma a estrutura de pasta a seguir em um bucket do Amazon S3. Se especificar a localização da pasta do Amazon S3 como *S3-bucket/Alexa-devices*, as imagens na pasta *echo* receberão o rótulo *echo*. Da mesma forma, as imagens na pasta *echo-dots* recebem o rótulo *echo-dot*. Os nomes das pastas secundárias mais profundas não são usados para rotular imagens. Em vez disso, é usada a pasta secundária apropriada da localização da pasta do Amazon S3. Por exemplo, as imagens na pasta *white-echo-dots*recebem o rótulo *echo-dot*. As imagens no nível da localização da pasta S3 (*alexa-devices*) não têm rótulos atribuídos a elas.
Pastas mais profundas na estrutura de pastas podem ser usadas para rotular imagens especificando uma localização mais profunda da pasta S3. Por exemplo, se você especificar *S3- bucket/alexa-devices/echo -dot*, as imagens na pasta *white-echo-dot*serão rotuladas. *white-echo-dot* As imagens fora do local especificado da pasta s3, como *echo*, não são importadas.
```
S3-bucket
└── alexa-devices
├── echo
│ ├── echo-image-1.png
│ └── echo-image-2.png
│ ├── .
│ └── .
└── echo-dot
├── white-echo-dot
│ ├── white-echo-dot-image-1.png
│ ├── white-echo-dot-image-2.png
│
├── echo-dot-image-1.png
├── echo-dot-image-2.png
├── .
└── .
```
Recomendamos que você use o bucket do Amazon S3 (bucket do console) criado para você pelo Amazon Rekognition quando você abriu o console pela primeira vez na região atual. AWS Se o bucket do Amazon S3 que você está usando for diferente (externo) do bucket do console, o console solicitará que você configure as permissões apropriadas durante a criação do conjunto de dados. Para obter mais informações, consulte [Etapa 2: configure as permissões do console do Amazon Rekognition Custom Labels](su-console-policy.md).
## Criação de um conjunto de dados importando imagens de um bucket do S3
O procedimento a seguir mostra como criar um conjunto de dados usando imagens armazenadas no bucket do Console S3. As imagens são automaticamente rotuladas com o nome da pasta na qual estão armazenadas.
Depois de importar suas imagens, é possível adicionar mais imagens, atribuir rótulos e adicionar caixas delimitadoras da página de galeria de um conjunto de dados. Para obter mais informações, consulte [Rotulagem de imagens](md-labeling-images.md).
**Faça upload das suas imagens em um bucket do Amazon Simple Storage Service**
1. Crie uma pasta no sistema de arquivos local. Use um nome de pasta, como *dispositivos-alexa*.
1. Na pasta que você acabou de criar, crie pastas com o nome de cada rótulo que você deseja usar. Por exemplo, *echo* e *echo-dot*. A estrutura deve ser semelhante à que vem a seguir.
```
alexa-devices
├── echo
│ ├── echo-image-1.png
│ ├── echo-image-2.png
│ ├── .
│ └── .
└── echo-dot
├── echo-dot-image-1.png
├── echo-dot-image-2.png
├── .
└── .
```
1. Coloque as imagens que correspondem a um rótulo na pasta com o mesmo nome do rótulo.
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. [Adicione a pasta](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) *que você criou na etapa 1 ao bucket do Amazon S3 (bucket do console) criado para você pelo Amazon Rekognition Custom Labels durante a Primeira configuração*. Para obter mais informações, consulte [Como gerenciar um projeto do Amazon Rekognition Custom Labels](managing-project.md).
1. Abra o console do Amazon Rekognition em. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Escolha **Usar rótulos personalizados**.
1. Escolha **Comece a usar**.
1. No painel de navegação esquerdo, selecione **Projetos**.
1. Na página **Projetos**, selecione o projeto ao qual você deseja adicionar um conjunto de dados. A página de detalhes do seu projeto é exibida.
1. Escolha **Criar conjunto de dados**. A página **Criar conjunto de dados** é exibida.
1. Em **Configuração inicial**, escolha **Iniciar com um único conjunto de dados** ou **Iniciar com um conjunto de dados de treinamento**. Para criar um modelo de maior qualidade, recomendamos começar com conjuntos de dados de treinamento e teste separados.
------
#### [ Single dataset ]
1. Na seção **Detalhes do conjunto de dados de treinamento**, escolha **Importar imagens do bucket do S3**.
1. Na seção **Detalhes do conjunto de dados de treinamento**, insira as informações das etapas 13 a 15 na seção **Configuração da fonte de imagem**.
------
#### [ Separate training and test datasets ]
1. Na seção **Detalhes do conjunto de dados de treinamento**, escolha **Importar imagens do bucket do S3**.
1. Na seção **Detalhes do conjunto de dados de treinamento**, insira as informações das etapas 13 a 15 na seção **Configuração da fonte de imagem**.
1. Na seção **Detalhes do conjunto de dados de teste**, escolha **Importar imagens do bucket do S3**.
1. Na seção **Detalhes do conjunto de dados de teste**, insira as informações das etapas 13 a 15 na seção **Configuração da fonte de imagem**.
------
1. Escolha **Importar imagens do bucket do Amazon S3**.
1. Em **S3 URI**, insira a localização do bucket do Amazon S3 e o caminho da pasta.
1. Escolha **Anexar rótulos automaticamente às imagens com base na pasta**.
1. Escolha **Criar conjuntos de dados**. A página de conjuntos de dados do seu projeto é aberta.
1. Se precisar adicionar ou alterar rótulos, faça [Rotulagem de imagens](md-labeling-images.md).
1. Siga as etapas em [Como treinar um modelo (console)](training-model.md#tm-console) para treinar seu modelo.
# Importar imagens de um computador local
As imagens são carregadas diretamente do seu computador. É possível fazer upload de até 30 imagens por vez.
As imagens que você enviar não terão rótulos associados a elas. Para obter mais informações, consulte [Rotulagem de imagens](md-labeling-images.md). Se tiver muitas imagens para carregar, considere usar um bucket do Amazon S3. Para obter mais informações, consulte [Importar imagens de um bucket do Amazon S3](md-create-dataset-s3.md).
**nota**
Você não pode usar o AWS SDK para criar um conjunto de dados com imagens locais. Em vez disso, crie um arquivo de manifesto e carregue as imagens em um bucket do Amazon S3. Para obter mais informações, consulte [Usar um arquivo de manifesto para importar imagens](md-create-dataset-ground-truth.md).
**Para criar um conjunto de dados usando imagens em um computador local (console)**
1. Abra o console do Amazon Rekognition em. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Escolha **Usar rótulos personalizados**.
1. Escolha **Comece a usar**.
1. No painel de navegação esquerdo, selecione **Projetos**.
1. Na página **Projetos**, selecione o projeto ao qual você deseja adicionar um conjunto de dados. A página de detalhes do seu projeto é exibida.
1. Escolha **Criar conjunto de dados**. A página **Criar conjunto de dados** é exibida.
1. Em **Configuração inicial**, escolha **Iniciar com um único conjunto de dados** ou **Iniciar com um conjunto de dados de treinamento**. Para criar um modelo de maior qualidade, recomendamos começar com conjuntos de dados de treinamento e teste separados.
------
#### [ Single dataset ]
1. Na seção **Detalhes do conjunto de dados de treinamento**, escolha **Fazer upload de imagens do seu computador**.
1. Escolha **Criar conjunto de dados**.
1. Na página do conjunto de dados do projeto, escolha **Adicionar imagens**.
1. Escolha as imagens que você deseja fazer upload no conjunto de dados dos arquivos do seu computador. É possível arrastar as imagens ou escolher as imagens que deseja carregar do seu computador local.
1. Escolha **Fazer upload de imagens**.
------
#### [ Separate training and test datasets ]
1. Na seção **Detalhes do conjunto de dados de treinamento**, escolha **Fazer upload de imagens do seu computador**.
1. Na seção **Detalhes do conjunto de dados de teste**, escolha **Fazer upload de imagens do seu computador**.
**nota**
Seus conjuntos de dados de treinamento e teste podem ter fontes de imagem diferentes.
1. Escolha **Criar conjuntos de dados**. A página do conjunto de dados do seu projeto aparece com uma guia **Treinamento** e uma guia **Teste** para os respectivos conjuntos de dados.
1. Escolha **Ações** e escolha **Adicionar imagens ao conjunto de dados de treinamento**.
1. Escolha as imagens que você deseja fazer upload no conjunto de dados. É possível arrastar as imagens ou escolher as imagens que deseja carregar do seu computador local.
1. Escolha **Fazer upload de imagens**.
1. Repita as etapas de 5e a 5g. Para a etapa 5e, escolha **Ações** e escolha **Adicionar imagens ao conjunto de dados de teste**.
------
1. Siga as etapas em [Rotulagem de imagens](md-labeling-images.md) para rotular suas imagens.
1. Siga as etapas em [Como treinar um modelo (console)](training-model.md#tm-console) para treinar o modelo.
# Usar um arquivo de manifesto para importar imagens
Você pode criar um conjunto de dados usando um arquivo de manifesto no formato Amazon SageMaker AI Ground Truth. Você pode usar o arquivo de manifesto de um trabalho do Amazon SageMaker AI Ground Truth. Se suas imagens e rótulos não estiverem no formato de um arquivo de manifesto do SageMaker AI Ground Truth, você poderá criar um arquivo de manifesto no formato SageMaker AI e usá-lo para importar suas imagens rotuladas.
A operação `CreateDataset` foi atualizada para permitir que você opte por especificar etiquetas ao criar um conjunto de dados. As etiquetas são pares de chave/valor que podem ajudar você a organizar e categorizar os recursos.
**Topics**
+ [Criação de um conjunto de dados com um arquivo de manifesto do SageMaker AI Ground Truth (console)](#md-create-dataset-ground-truth-console)
+ [Criação de um conjunto de dados com um arquivo de manifesto (SDK) do SageMaker AI Ground Truth](#md-create-dataset-ground-truth-sdk)
+ [Criar solicitação de conjunto de dados](#create-dataset-ground-truth-request)
+ [Rotulando imagens com um trabalho do Amazon SageMaker AI Ground Truth](md-create-dataset-ground-truth-job.md)
+ [Criar um arquivo de manifesto](md-create-manifest-file.md)
+ [Importar rótulos ao nível da imagem em arquivos de manifesto](md-create-manifest-file-classification.md)
+ [Localização de objetos em arquivos de manifesto](md-create-manifest-file-object-detection.md)
+ [Regras de validação para arquivos de manifesto](md-create-manifest-file-validation-rules.md)
+ [Conversão de outros formatos de conjunto de dados em um arquivo de manifesto](md-converting-to-sm-format.md)
## Criação de um conjunto de dados com um arquivo de manifesto do SageMaker AI Ground Truth (console)
O procedimento a seguir mostra como criar um conjunto de dados usando um arquivo de manifesto no formato SageMaker AI Ground Truth.
1. Crie um arquivo de manifesto para o conjunto de dados de treinamento seguindo um destes procedimentos:
+ Crie um arquivo de manifesto com um SageMaker AI GroundTruth Job seguindo as instruções em[Rotulando imagens com um trabalho do Amazon SageMaker AI Ground Truth](md-create-dataset-ground-truth-job.md).
+ Crie seu próprio arquivo de manifesto seguindo as instruções em [Criar um arquivo de manifesto](md-create-manifest-file.md).
Se quiser criar um conjunto de dados de teste, repita a etapa 1 para criar o conjunto de dados de teste.
1. Abra o console do Amazon Rekognition em. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Escolha **Usar rótulos personalizados**.
1. Escolha **Comece a usar**.
1. No painel de navegação esquerdo, selecione **Projetos**.
1. Na página **Projetos**, selecione o projeto ao qual você deseja adicionar um conjunto de dados. A página de detalhes do seu projeto é exibida.
1. Escolha **Criar conjunto de dados**. A página **Criar conjunto de dados** é exibida.
1. Em **Configuração inicial**, escolha **Iniciar com um único conjunto de dados** ou **Iniciar com um conjunto de dados de treinamento**. Para criar um modelo de maior qualidade, recomendamos começar com conjuntos de dados de treinamento e teste separados.
------
#### [ Single dataset ]
1. Na seção **Detalhes do conjunto de dados de treinamento**, escolha **Importar imagens rotuladas por SageMaker Ground** Truth.
1. No **local do arquivo de manifesto**, insira o local do arquivo de manifesto criado na etapa 1.
1. Escolha **Criar conjunto de dados**. A página de conjuntos de dados do seu projeto é aberta.
------
#### [ Separate training and test datasets ]
1. Na seção **Detalhes do conjunto de dados de treinamento**, escolha **Importar imagens rotuladas por SageMaker Ground** Truth.
1. No **local do arquivo de manifesto**, insira o local do arquivo de manifesto do conjunto de dados de treinamento criado na etapa 1.
1. Na seção **Detalhes do conjunto de dados de teste**, escolha **Importar imagens rotuladas por SageMaker Ground Truth**.
**nota**
Seus conjuntos de dados de treinamento e teste podem ter fontes de imagem diferentes.
1. No **local do arquivo de manifesto**, insira o local do arquivo de manifesto do conjunto de dados de teste criado na etapa 1.
1. Escolha **Criar conjuntos de dados**. A página de conjuntos de dados do seu projeto é aberta.
------
1. Se precisar adicionar ou alterar rótulos, faça [Rotulagem de imagens](md-labeling-images.md).
1. Siga as etapas em [Como treinar um modelo (console)](training-model.md#tm-console) para treinar seu modelo.
## Criação de um conjunto de dados com um arquivo de manifesto (SDK) do SageMaker AI Ground Truth
O procedimento a seguir mostra como criar conjuntos de dados de treinamento ou teste a partir de um arquivo de manifesto usando a [CreateDataset](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateDataset)API.
Você pode usar um arquivo de manifesto existente, como a saída de um [trabalho do SageMaker AI Ground Truth](md-create-dataset-ground-truth-job.md), ou criar seu próprio [arquivo de manifesto](md-create-manifest-file.md).
1. Se você ainda não tiver feito isso, instale e configure o AWS CLI e AWS SDKs o. Para obter mais informações, consulte [Etapa 4: configurar o AWS CLI e AWS SDKs](su-awscli-sdk.md).
1. Crie um arquivo de manifesto para o conjunto de dados de treinamento seguindo um destes procedimentos:
+ Crie um arquivo de manifesto com um SageMaker AI GroundTruth Job seguindo as instruções em[Rotulando imagens com um trabalho do Amazon SageMaker AI Ground Truth](md-create-dataset-ground-truth-job.md).
+ Crie seu próprio arquivo de manifesto seguindo as instruções em [Criar um arquivo de manifesto](md-create-manifest-file.md).
Se quiser criar um conjunto de dados de teste, repita a etapa 2 para criar o conjunto de dados de teste.
1. Use o código de exemplo a seguir para criar o conjunto de dados de treinamento e teste.
------
#### [ AWS CLI ]
Use o código a seguir para criar um conjunto de dados. Substitua o seguinte:
+ `project_arn`: o ARN do projeto ao qual você deseja adicionar o conjunto de dados de teste.
+ `type`: o tipo de conjunto de dados que você deseja criar (TREINAMENTO ou TESTE).
+ `bucket`: o bucket que contém o arquivo de manifesto do conjunto de dados.
+ `manifest_file`: o caminho e o nome do arquivo de manifesto.
```
aws rekognition create-dataset --project-arn project_arn \
--dataset-type type \
--dataset-source '{ "GroundTruthManifest": { "S3Object": { "Bucket": "bucket", "Name": "manifest_file" } } }' \
--profile custom-labels-access
--tags '{"key1": "value1", "key2": "value2"}'
```
------
#### [ Python ]
Use os valores a seguir para criar um conjunto de dados. Forneça os seguintes parâmetros de linha de comando:
+ `project_arn`: o ARN do projeto ao qual você deseja adicionar o conjunto de dados de teste.
+ `dataset_type`: o tipo de conjunto de dados que você deseja criar (`train` ou `test`).
+ `bucket`: o bucket que contém o arquivo de manifesto do conjunto de dados.
+ `manifest_file`: o caminho e o nome do arquivo de manifesto.
```
#Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
#PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-custom-labels-developer-guide/blob/master/LICENSE-SAMPLECODE.)
import argparse
import logging
import time
import json
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def create_dataset(rek_client, project_arn, dataset_type, bucket, manifest_file):
"""
Creates an Amazon Rekognition Custom Labels dataset.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param project_arn: The ARN of the project in which you want to create a dataset.
:param dataset_type: The type of the dataset that you want to create (train or test).
:param bucket: The S3 bucket that contains the manifest file.
:param manifest_file: The path and filename of the manifest file.
"""
try:
#Create the project
logger.info("Creating %s dataset for project %s",dataset_type, project_arn)
dataset_type = dataset_type.upper()
dataset_source = json.loads(
'{ "GroundTruthManifest": { "S3Object": { "Bucket": "'
+ bucket
+ '", "Name": "'
+ manifest_file
+ '" } } }'
)
response = rek_client.create_dataset(
ProjectArn=project_arn, DatasetType=dataset_type, DatasetSource=dataset_source
)
dataset_arn=response['DatasetArn']
logger.info("dataset ARN: %s",dataset_arn)
finished=False
while finished is False:
dataset=rek_client.describe_dataset(DatasetArn=dataset_arn)
status=dataset['DatasetDescription']['Status']
if status == "CREATE_IN_PROGRESS":
logger.info("Creating dataset: %s ",dataset_arn)
time.sleep(5)
continue
if status == "CREATE_COMPLETE":
logger.info("Dataset created: %s", dataset_arn)
finished=True
continue
if status == "CREATE_FAILED":
error_message = f"Dataset creation failed: {status} : {dataset_arn}"
logger.exception(error_message)
raise Exception (error_message)
error_message = f"Failed. Unexpected state for dataset creation: {status} : {dataset_arn}"
logger.exception(error_message)
raise Exception(error_message)
return dataset_arn
except ClientError as err:
logger.exception("Couldn't create dataset: %s",err.response['Error']['Message'])
raise
def add_arguments(parser):
"""
Adds command line arguments to the parser.
:param parser: The command line parser.
"""
parser.add_argument(
"project_arn", help="The ARN of the project in which you want to create the dataset."
)
parser.add_argument(
"dataset_type", help="The type of the dataset that you want to create (train or test)."
)
parser.add_argument(
"bucket", help="The S3 bucket that contains the manifest file."
)
parser.add_argument(
"manifest_file", help="The path and filename of the manifest file."
)
def main():
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
try:
#Get command line arguments.
parser = argparse.ArgumentParser(usage=argparse.SUPPRESS)
add_arguments(parser)
args = parser.parse_args()
print(f"Creating {args.dataset_type} dataset for project {args.project_arn}")
#Create the dataset.
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
dataset_arn=create_dataset(rekognition_client,
args.project_arn,
args.dataset_type,
args.bucket,
args.manifest_file)
print(f"Finished creating dataset: {dataset_arn}")
except ClientError as err:
logger.exception("Problem creating dataset: %s", err)
print(f"Problem creating dataset: {err}")
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
Use os valores a seguir para criar um conjunto de dados. Forneça os seguintes parâmetros de linha de comando:
+ `project_arn`: o ARN do projeto ao qual você deseja adicionar o conjunto de dados de teste.
+ `dataset_type`: o tipo de conjunto de dados que você deseja criar (`train` ou `test`).
+ `bucket`: o bucket que contém o arquivo de manifesto do conjunto de dados.
+ `manifest_file`: o caminho e o nome do arquivo de manifesto.
```
/*
Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
SPDX-License-Identifier: Apache-2.0
*/
package com.example.rekognition;
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.CreateDatasetRequest;
import software.amazon.awssdk.services.rekognition.model.CreateDatasetResponse;
import software.amazon.awssdk.services.rekognition.model.DatasetDescription;
import software.amazon.awssdk.services.rekognition.model.DatasetSource;
import software.amazon.awssdk.services.rekognition.model.DatasetStatus;
import software.amazon.awssdk.services.rekognition.model.DatasetType;
import software.amazon.awssdk.services.rekognition.model.DescribeDatasetRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeDatasetResponse;
import software.amazon.awssdk.services.rekognition.model.GroundTruthManifest;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import software.amazon.awssdk.services.rekognition.model.S3Object;
import java.util.logging.Level;
import java.util.logging.Logger;
public class CreateDatasetManifestFiles {
public static final Logger logger = Logger.getLogger(CreateDatasetManifestFiles.class.getName());
public static String createMyDataset(RekognitionClient rekClient, String projectArn, String datasetType,
String bucket, String name) throws Exception, RekognitionException {
try {
logger.log(Level.INFO, "Creating {0} dataset for project : {1} from s3://{2}/{3} ",
new Object[] { datasetType, projectArn, bucket, name });
DatasetType requestDatasetType = null;
switch (datasetType) {
case "train":
requestDatasetType = DatasetType.TRAIN;
break;
case "test":
requestDatasetType = DatasetType.TEST;
break;
default:
logger.log(Level.SEVERE, "Could not create dataset. Unrecognized dataset type: {0}", datasetType);
throw new Exception("Could not create dataset. Unrecognized dataset type: " + datasetType);
}
GroundTruthManifest groundTruthManifest = GroundTruthManifest.builder()
.s3Object(S3Object.builder().bucket(bucket).name(name).build()).build();
DatasetSource datasetSource = DatasetSource.builder().groundTruthManifest(groundTruthManifest).build();
CreateDatasetRequest createDatasetRequest = CreateDatasetRequest.builder().projectArn(projectArn)
.datasetType(requestDatasetType).datasetSource(datasetSource).build();
CreateDatasetResponse response = rekClient.createDataset(createDatasetRequest);
boolean created = false;
do {
DescribeDatasetRequest describeDatasetRequest = DescribeDatasetRequest.builder()
.datasetArn(response.datasetArn()).build();
DescribeDatasetResponse describeDatasetResponse = rekClient.describeDataset(describeDatasetRequest);
DatasetDescription datasetDescription = describeDatasetResponse.datasetDescription();
DatasetStatus status = datasetDescription.status();
logger.log(Level.INFO, "Creating dataset ARN: {0} ", response.datasetArn());
switch (status) {
case CREATE_COMPLETE:
logger.log(Level.INFO, "Dataset created");
created = true;
break;
case CREATE_IN_PROGRESS:
Thread.sleep(5000);
break;
case CREATE_FAILED:
String error = "Dataset creation failed: " + datasetDescription.statusAsString() + " "
+ datasetDescription.statusMessage() + " " + response.datasetArn();
logger.log(Level.SEVERE, error);
throw new Exception(error);
default:
String unexpectedError = "Unexpected creation state: " + datasetDescription.statusAsString() + " "
+ datasetDescription.statusMessage() + " " + response.datasetArn();
logger.log(Level.SEVERE, unexpectedError);
throw new Exception(unexpectedError);
}
} while (created == false);
return response.datasetArn();
} catch (RekognitionException e) {
logger.log(Level.SEVERE, "Could not create dataset: {0}", e.getMessage());
throw e;
}
}
public static void main(String[] args) {
String datasetType = null;
String bucket = null;
String name = null;
String projectArn = null;
String datasetArn = null;
final String USAGE = "\n" + "Usage: " + " \n\n" + "Where:\n"
+ " project_arn - the ARN of the project that you want to add copy the datast to.\n\n"
+ " dataset_type - the type of the dataset that you want to create (train or test).\n\n"
+ " bucket - the S3 bucket that contains the manifest file.\n\n"
+ " name - the location and name of the manifest file within the bucket.\n\n";
if (args.length != 4) {
System.out.println(USAGE);
System.exit(1);
}
projectArn = args[0];
datasetType = args[1];
bucket = args[2];
name = args[3];
try {
// Get the Rekognition client
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// Create the dataset
datasetArn = createMyDataset(rekClient, projectArn, datasetType, bucket, name);
System.out.println(String.format("Created dataset: %s", datasetArn));
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
} catch (Exception rekError) {
logger.log(Level.SEVERE, "Error: {0}", rekError.getMessage());
System.exit(1);
}
}
}
```
------
1. Se precisar adicionar ou alterar rótulos, consulte [Como gerenciar rótulos (SDK)](md-labels.md#md-labels-sdk).
1. Siga as etapas em [Treinando um modelo (SDK)](training-model.md#tm-sdk) para treinar seu modelo.
## Criar solicitação de conjunto de dados
Veja a seguir o formato da solicitação de CreateDataset operação:
```
{
"DatasetSource": {
"DatasetArn": "string",
"GroundTruthManifest": {
"S3Object": {
"Bucket": "string",
"Name": "string",
"Version": "string"
}
}
},
"DatasetType": "string",
"ProjectArn": "string",
"Tags": {
"string": "string"
}
}
```
# Rotulando imagens com um trabalho do Amazon SageMaker AI Ground Truth
Com o Amazon SageMaker AI Ground Truth, você pode usar trabalhadores da Amazon Mechanical Turk, uma empresa fornecedora de sua escolha, ou de uma força de trabalho interna e privada, juntamente com o aprendizado de máquina que permite criar um conjunto rotulado de imagens. O Amazon Rekognition Custom Labels SageMaker importa arquivos de manifesto do AI Ground Truth de um bucket do Amazon S3 que você especificar.
O Amazon Rekognition Custom Labels oferece suporte às seguintes tarefas do AI Ground Truth. SageMaker
+ [Classificação de imagens](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-image-classification.html)
+ [Caixa delimitadora](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-bounding-box.html)
Os arquivos que você importa são as imagens e um arquivo de manifesto. O arquivo de manifesto contém informações do rótulo e da caixa delimitadora das imagens que você importa.
O Amazon Rekognition precisa de permissões para acessar o bucket do Amazon S3 onde suas imagens são armazenadas. Se estiver usando o bucket de console configurado para você pelo Amazon Rekognition Custom Labels, as permissões necessárias já estão configuradas. Se não estiver usando o bucket do console, consulte [Como acessar os buckets externos do Amazon S3](su-console-policy.md#su-external-buckets).
## Criação de um arquivo de manifesto com um trabalho do SageMaker AI Ground Truth (console)
O procedimento a seguir mostra como criar um conjunto de dados usando imagens rotuladas por um trabalho do SageMaker AI Ground Truth. Os arquivos de saída do trabalho são armazenados no bucket do console do Amazon Rekognition Custom Labels.
**Para criar um conjunto de dados usando imagens rotuladas por um trabalho do SageMaker AI Ground Truth (console)**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. No bucket do console, [crie uma pasta](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-folder.html) para armazenar suas imagens de treinamento.
**nota**
O bucket do console é criado quando você abre pela primeira vez o console Amazon Rekognition Custom Labels em uma região. AWS Para obter mais informações, consulte [Como gerenciar um projeto do Amazon Rekognition Custom Labels](managing-project.md).
1. [Faça upload de suas imagens](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) na pasta que acabou de criar.
1. No bucket do console, crie uma pasta para armazenar a saída do trabalho do Ground Truth.
1. Abra o console de SageMaker IA em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Crie um trabalho de rotulagem do Ground Truth. Você precisará do Amazon S3 URLs para as pastas que você criou nas etapas 2 e 4. Para obter mais informações, consulte [Use Amazon SageMaker Ground Truth for Data Labeling](https://docs.aws.amazon.com/sagemaker/latest/dg/sms.html).
1. Observe a localização do arquivo `output.manifest` na pasta que você criou na etapa 4. Ele deve estar na subpasta `Ground-Truth-Job-Name/manifests/output`.
1. Siga as instruções em [Criação de um conjunto de dados com um arquivo de manifesto do SageMaker AI Ground Truth (console)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console) para criar um conjunto de dados com o arquivo de manifesto carregado. Para a etapa 8, na **localização do arquivo .manifest**, insira a URL do Amazon S3 para a localização que você anotou na etapa anterior. Se você estiver usando o AWS SDK, use[Criação de um conjunto de dados com um arquivo de manifesto (SDK) do SageMaker AI Ground Truth](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk).
1. Repita as etapas 1 a 6 para criar a tarefa SageMaker AI Ground Truth para seu conjunto de dados de teste.
# Criar um arquivo de manifesto
Você pode criar um conjunto de dados de teste ou treinamento importando um arquivo de manifesto no formato SageMaker AI Ground Truth. Se suas imagens estiverem rotuladas em um formato que não seja um arquivo de manifesto do SageMaker AI Ground Truth, use as informações a seguir para criar um arquivo de manifesto no formato SageMaker AI Ground Truth.
Os arquivos de manifesto estão no formato de [linhas JSON](http://jsonlines.org), onde cada linha é um objeto JSON completo representando as informações de rotulagem de uma imagem. O Amazon Rekognition Custom Labels SageMaker suporta manifestos AI Ground Truth com linhas JSON nos seguintes formatos:
+ [Saída do trabalho de classificação](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html#sms-output-class): use para adicionar rótulos em nível de imagem a uma imagem. Um rótulo em nível de imagem define a classe de cena, conceito ou objeto (se as informações de localização do objeto não forem necessárias) que está em uma imagem. Uma imagem pode ter mais de um rótulo no nível da imagem. Para obter mais informações, consulte [Importar rótulos ao nível da imagem em arquivos de manifesto](md-create-manifest-file-classification.md).
+ [Saída do trabalho da caixa delimitadora](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html#sms-output-box): use para rotular a classe e a localização de um ou mais objetos em uma imagem. Para obter mais informações, consulte [Localização de objetos em arquivos de manifesto](md-create-manifest-file-object-detection.md).
As linhas JSON em nível de imagem e localização (caixa delimitadora) podem ser encadeadas no mesmo arquivo de manifesto.
**nota**
Os exemplos de linhas JSON nesta seção são formatados para facilitar a leitura.
Ao importar um arquivo de manifesto, o Amazon Rekognition Custom Labels aplica regras de validação para limites, sintaxe e semântica. Para obter mais informações, consulte [Regras de validação para arquivos de manifesto](md-create-manifest-file-validation-rules.md).
As imagens referenciadas por um arquivo de manifesto devem estar localizadas no mesmo bucket do Amazon S3. O arquivo de manifesto pode estar localizado em um bucket do Amazon S3 diferente do bucket do Amazon S3 que armazena as imagens. A localização de uma imagem é especificada no campo `source-ref` de uma linha JSON.
O Amazon Rekognition precisa de permissões para acessar o bucket do Amazon S3 onde suas imagens são armazenadas. Se estiver usando o bucket de console configurado para você pelo Amazon Rekognition Custom Labels, as permissões necessárias já estão configuradas. Se não estiver usando o bucket do console, consulte [Como acessar os buckets externos do Amazon S3](su-console-policy.md#su-external-buckets).
**Topics**
+ [Como criar um arquivo de manifesto](#md-create-manifest-file-console)
## Como criar um arquivo de manifesto
O procedimento a seguir cria um projeto com um conjunto de dados de treinamento e teste. Os conjuntos de dados são criados a partir dos arquivos de manifesto de treinamento e teste que você cria.
**Para criar um conjunto de dados usando um arquivo de manifesto no formato SageMaker AI Ground Truth (console)**
1. No bucket do console, [crie uma pasta](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-folder.html) para armazenar seus arquivos de manifesto.
1. No bucket do console, crie uma pasta para armazenar suas imagens.
1. Faça upload de suas imagens na pasta que acabou de criar.
1. Crie um arquivo de manifesto no formato SageMaker AI Ground Truth para seu conjunto de dados de treinamento. Para obter mais informações, consulte [Importar rótulos ao nível da imagem em arquivos de manifesto](md-create-manifest-file-classification.md) e [Localização de objetos em arquivos de manifesto](md-create-manifest-file-object-detection.md).
**Importante**
O valor do campo `source-ref` em cada linha JSON deve ser mapeado para uma imagem que você carregou.
1. Crie um arquivo de manifesto no formato SageMaker AI Ground Truth para seu conjunto de dados de teste.
1. [Faça upload de seus arquivos de manifesto](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) na pasta que acabou de criar.
1. Observe a localização do arquivo de manifesto.
1. Siga as instruções em [Criação de um conjunto de dados com um arquivo de manifesto do SageMaker AI Ground Truth (console)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console) para criar um conjunto de dados com o arquivo de manifesto carregado. Para a etapa 8, na **localização do arquivo .manifest**, insira a URL do Amazon S3 para a localização que você anotou na etapa anterior. Se você estiver usando o AWS SDK, use[Criação de um conjunto de dados com um arquivo de manifesto (SDK) do SageMaker AI Ground Truth](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk).
# Importar rótulos ao nível da imagem em arquivos de manifesto
Para importar rótulos em nível de imagem (imagens rotuladas com cenas, conceitos ou objetos que não exigem informações de localização), você adiciona linhas JSON no formato JSON do formato AI Ground SageMaker Truth Classification [Job Output](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html#sms-output-class) a um arquivo de manifesto. Um arquivo de manifesto é feito de uma ou mais linhas JSON, uma para cada imagem que você deseja importar.
**dica**
Para simplificar a criação de um arquivo de manifesto, fornecemos um script em Python que cria um arquivo de manifesto a partir de um arquivo CSV. Para obter mais informações, consulte [Como criar um arquivo de manifesto de um arquivo CSV](ex-csv-manifest.md).
**Para criar um arquivo de manifesto para rótulos em nível de imagem**
1. Crie um arquivo de texto vazio.
1. Adicione uma linha JSON para cada imagem que você deseja importar. Cada linha deve ser semelhante à linha a seguir.
```
{"source-ref":"s3://custom-labels-console-us-east-1-nnnnnnnnnn/gt-job/manifest/IMG_1133.png","TestCLConsoleBucket":0,"TestCLConsoleBucket-metadata":{"confidence":0.95,"job-name":"labeling-job/testclconsolebucket","class-name":"Echo Dot","human-annotated":"yes","creation-date":"2020-04-15T20:17:23.433061","type":"groundtruth/image-classification"}}
```
1. Salve o arquivo. É possível usar a extensão `.manifest`, mas ela não é obrigatória.
1. Crie um conjunto de dados usando o arquivo de manifesto que você criou. Para obter mais informações, consulte [Para criar um conjunto de dados usando um arquivo de manifesto no formato SageMaker AI Ground Truth (console)](md-create-manifest-file.md#create-dataset-procedure-manifest-file).
## Linhas JSON em nível de imagem
Nesta seção, é mostrado como criar uma linha JSON para uma única imagem. Considere a seguinte imagem: Uma cena para a imagem a seguir pode ser chamada de *Sunrise*.
![\[Pôr do sol sobre um lago com doca e pequenos barcos, e montanhas nos arredores.\]](http://docs.aws.amazon.com/pt_br/rekognition/latest/customlabels-dg/images/sunrise.png)
A linha JSON da imagem anterior, com a cena *Nascer do sol*, pode ser a seguinte.
```
{
"source-ref": "s3://bucket/images/sunrise.png",
"testdataset-classification_Sunrise": 1,
"testdataset-classification_Sunrise-metadata": {
"confidence": 1,
"job-name": "labeling-job/testdataset-classification_Sunrise",
"class-name": "Sunrise",
"human-annotated": "yes",
"creation-date": "2020-03-06T17:46:39.176",
"type": "groundtruth/image-classification"
}
}
```
Observe as seguintes informações:
### source-ref
(Obrigatório) O local no Amazon S3 da imagem. O formato é `"s3://BUCKET/OBJECT_PATH"`. As imagens em um conjunto de dados importado devem ser armazenadas no mesmo bucket do Amazon S3.
### *testdataset-classification\$1Sunrise*
(Obrigatório) O atributo do rótulo. Escolha o nome do campo. O valor do campo (1 no exemplo anterior) é um identificador de atributo de rótulo. Ele não é usado pelo Amazon Rekognition Custom Labels e pode ter qualquer valor inteiro. Deve haver metadados correspondentes identificados pelo nome do campo com *-metadata* anexado. Por exemplo, .`"testdataset-classification_Sunrise-metadata"`
### *testdataset-classification\$1Sunrise*-metadados
(Obrigatório) Metadados sobre o atributo do rótulo. O nome do campo deve ser o mesmo do atributo do rótulo com *-metadata* anexado.
*confidence*
(Obrigatório) Atualmente não é usado pelo Amazon Rekognition Custom Labels, mas um valor entre 0 e 1 deve ser fornecido.
*job-name*
(Opcional) Um nome que você escolhe para o trabalho que processa a imagem.
*class-name*
(Obrigatório) Um nome de classe que você escolhe para a cena ou conceito que se aplica à imagem. Por exemplo, .`"Sunrise"`
*human-annotated*
(Obrigatório) Especifique `"yes"` se a anotação foi preenchida por um humano. Caso contrário, `"no"`.
*creation-date*
(Obrigatório) A data e hora do Tempo Universal Coordenado (UTC) em que o rótulo foi criado.
*tipo*
(Obrigatório) O tipo de processamento que deve ser aplicado à imagem. Para rótulos em nível de imagem, o valor é `"groundtruth/image-classification"`.
### Como adicionar vários rótulos em nível de imagem a uma imagem
É possível adicionar vários rótulos a uma imagem. Por exemplo, o JSON a seguir adiciona dois rótulos, *futebol* e *bola*, a uma única imagem.
```
{
"source-ref": "S3 bucket location",
"sport0":0, # FIRST label
"sport0-metadata": {
"class-name": "football",
"confidence": 0.8,
"type":"groundtruth/image-classification",
"job-name": "identify-sport",
"human-annotated": "yes",
"creation-date": "2018-10-18T22:18:13.527256"
},
"sport1":1, # SECOND label
"sport1-metadata": {
"class-name": "ball",
"confidence": 0.8,
"type":"groundtruth/image-classification",
"job-name": "identify-sport",
"human-annotated": "yes",
"creation-date": "2018-10-18T22:18:13.527256"
}
} # end of annotations for 1 image
```
# Localização de objetos em arquivos de manifesto
Você pode importar imagens rotuladas com informações de localização de objetos adicionando linhas JSON no formato SageMaker AI Ground Truth [Bounding Box Job](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html#sms-output-box) Output a um arquivo de manifesto.
As informações de localização representam a localização de um objeto em uma imagem. A localização é representada por uma caixa delimitadora que circunda o objeto. A estrutura da caixa delimitadora contém as coordenadas no canto superior esquerdo da caixa delimitadora e a largura e altura da caixa delimitadora. Uma linha JSON em formato de caixa delimitadora inclui caixas delimitadoras para a localização de um ou mais objetos em uma imagem e a classe de cada objeto na imagem.
Um arquivo de manifesto é feito de uma ou mais linhas JSON, cada linha contém as informações de uma única imagem.
**Para criar um arquivo de manifesto para localização de objetos**
1. Crie um arquivo de texto vazio.
1. Adicione uma linha JSON para cada imagem que você deseja importar. Cada linha deve ser semelhante à linha a seguir.
```
{"source-ref": "s3://bucket/images/IMG_1186.png", "bounding-box": {"image_size": [{"width": 640, "height": 480, "depth": 3}], "annotations": [{ "class_id": 1, "top": 251, "left": 399, "width": 155, "height": 101}, {"class_id": 0, "top": 65, "left": 86, "width": 220, "height": 334}]}, "bounding-box-metadata": {"objects": [{ "confidence": 1}, {"confidence": 1}], "class-map": {"0": "Echo", "1": "Echo Dot"}, "type": "groundtruth/object-detection", "human-annotated": "yes", "creation-date": "2013-11-18T02:53:27", "job-name": "my job"}}
```
1. Salve o arquivo. É possível usar a extensão `.manifest`, mas ela não é obrigatória.
1. Crie um conjunto de dados usando o arquivo que você criou. Para obter mais informações, consulte [Para criar um conjunto de dados usando um arquivo de manifesto no formato SageMaker AI Ground Truth (console)](md-create-manifest-file.md#create-dataset-procedure-manifest-file).
## Linhas JSON da caixa delimitadora de objetos
Nesta seção, é mostrado como criar uma linha JSON para uma única imagem. A imagem a seguir mostra as caixas delimitadoras ao redor de dispositivos Amazon Echo e um Amazon Echo Dot.
![\[Dois alto-falantes inteligentes da Amazon, um com caixa delimitadora verde e um com caixa delimitadora azul, em uma superfície de madeira.\]](http://docs.aws.amazon.com/pt_br/rekognition/latest/customlabels-dg/images/echos.png)
A seguir está a linha JSON da caixa delimitadora da imagem anterior.
```
{
"source-ref": "s3://custom-labels-bucket/images/IMG_1186.png",
"bounding-box": {
"image_size": [{
"width": 640,
"height": 480,
"depth": 3
}],
"annotations": [{
"class_id": 1,
"top": 251,
"left": 399,
"width": 155,
"height": 101
}, {
"class_id": 0,
"top": 65,
"left": 86,
"width": 220,
"height": 334
}]
},
"bounding-box-metadata": {
"objects": [{
"confidence": 1
}, {
"confidence": 1
}],
"class-map": {
"0": "Echo",
"1": "Echo Dot"
},
"type": "groundtruth/object-detection",
"human-annotated": "yes",
"creation-date": "2013-11-18T02:53:27",
"job-name": "my job"
}
}
```
Observe as seguintes informações:
### source-ref
(Obrigatório) O local no Amazon S3 da imagem. O formato é `"s3://BUCKET/OBJECT_PATH"`. As imagens em um conjunto de dados importado devem ser armazenadas no mesmo bucket do Amazon S3.
### *bounding-box*
(Obrigatório) O atributo do rótulo. Escolha o nome do campo. Contém o tamanho da imagem e as caixas delimitadoras de cada objeto detectado na imagem. Deve haver metadados correspondentes identificados pelo nome do campo com *-metadata* anexado. Por exemplo, .`"bounding-box-metadata"`
*image\$1size*
(Obrigatório) Uma matriz de elementos únicos contendo o tamanho da imagem em pixels.
+ *height*: (obrigatória) a altura da imagem em pixels.
+ *width*: (obrigatório) a profundidade da imagem em pixels.
+ *depth*: (obrigatório) o número de canais na imagem. Para imagens RGB, o valor é 3. Não é usado pelo Amazon Rekognition Custom Labels neste momento, mas um valor é obrigatório.
*anotações*
(Obrigatório) Uma matriz de informações da caixa delimitadora para cada objeto detectado na imagem.
+ *class\$1id* (obrigatório) mapeia para o rótulo no *class-map*. No exemplo anterior, o objeto com o *class\$1id* de `1` é o Echo Dot na imagem.
+ *top*: (obrigatório) a distância da parte superior da imagem à parte superior da caixa delimitadora, em pixels.
+ *left*: (obrigatório) a distância da esquerda da imagem à esquerda da caixa delimitadora, em pixels.
+ *width*: (obrigatório) a largura da caixa delimitadora em pixels.
+ *height*: (obrigatória) a altura da caixa delimitadora em pixels.
### *bounding-box*-metadados
(Obrigatório) Metadados sobre o atributo do rótulo. O nome do campo deve ser o mesmo do atributo do rótulo com *-metadata* anexado. Uma matriz de informações da caixa delimitadora para cada objeto detectado na imagem.
*Objetos*
(Obrigatório) Uma matriz de objetos que estão na imagem. Mapeia para a matriz de *anotações* por índice. O atributo de confiança não é usado pelo Amazon Rekognition Custom Labels.
*class-map*
(Obrigatório) Um mapa das classes que se aplicam aos objetos detectados na imagem.
*tipo*
(Obrigatório) O tipo de trabalho de classificação. `"groundtruth/object-detection"` identifica o trabalho como detecção de objetos.
*creation-date*
(Obrigatório) A data e hora do Tempo Universal Coordenado (UTC) em que o rótulo foi criado.
*human-annotated*
(Obrigatório) Especifique `"yes"` se a anotação foi preenchida por um humano. Caso contrário, `"no"`.
*job-name*
(Opcional) O nome do trabalho que processa a imagem.
# Regras de validação para arquivos de manifesto
Ao importar um arquivo de manifesto, o Amazon Rekognition Custom Labels aplica regras de validação para limites, sintaxe e semântica. O esquema SageMaker AI Ground Truth impõe a validação da sintaxe. Para obter mais informações, consulte [Saídas](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html). A seguir estão as regras de validação para limites e semântica.
**nota**
As regras de invalidade de 20% se aplicam cumulativamente a todas as regras de validação. Se a importação exceder o limite de 20% devido a qualquer combinação, como 15% de JSON inválido e 15% de imagens inválidas, a importação falhará.
Cada objeto do conjunto de dados é uma linha no manifesto. Linhas em branco/inválidas também são contadas como objetos do conjunto de dados.
As sobreposições são (rótulos comuns entre teste e treinamento)/(rótulos de treinamento).
**Topics**
+ [Limites](#md-validation-rules-limits)
+ [Semântica](#md-validation-rules-semantics)
## Limites
| Validação | Limite | Erro gerado |
| --- | --- | --- |
| Tamanho do arquivo de manifesto | Máximo de 1 GB | Erro |
| Contagem máxima de linhas para um arquivo de manifesto | Máximo de 250 mil objetos do conjunto de dados como linhas em um manifesto. | Erro |
| Limite inferior no número total de objetos de conjunto de dados válidos por rótulo | >=1 | Erro |
| Limite inferior nos rótulos | >=2 | Erro |
| Limite superior nos rótulos | <= 250 | Erro |
| Mínimo de caixas delimitadoras por imagem | 0 | Nenhum |
| Máximo de caixas delimitadoras por imagem | 50 | Nenhum |
## Semântica
| Validação | Limite | Erro gerado |
| --- | --- | --- |
| Manifesto vazio | | Erro |
| Objeto /in-accessible source-ref ausente | Número de objetos menor que 20% | Aviso |
| Objeto /in-accessible source-ref ausente | Número de objetos > 20% | Erro |
| Rótulos de teste não presentes no conjunto de dados de treinamento | Pelo menos 50% de sobreposição nos rótulos | Erro |
| Combinação de exemplos de rótulos versus objetos para o mesmo rótulo em um conjunto de dados. Classificação e detecção da mesma classe em um objeto de conjunto de dados. | | Nenhum erro ou aviso |
| Como sobrepor ativos entre teste e treinamento | Não deve haver uma sobreposição entre os conjuntos de dados de teste e treinamento. | |
| As imagens em um conjunto de dados devem ser do mesmo bucket | Erro se os objetos estiverem em um bucket diferente | Erro |
# Conversão de outros formatos de conjunto de dados em um arquivo de manifesto
Você pode usar as informações a seguir para criar arquivos de manifesto no formato Amazon SageMaker AI a partir de uma variedade de formatos de conjuntos de dados de origem. Depois de criar o arquivo de manifesto, use-o para criar um conjunto de dados. Para obter mais informações, consulte [Usar um arquivo de manifesto para importar imagens](md-create-dataset-ground-truth.md).
**Topics**
+ [Transformar um conjunto de dados COCO em um formato de arquivo de manifesto](md-transform-coco.md)
+ [Transformando arquivos de manifesto com vários rótulos do SageMaker AI Ground Truth](md-gt-cl-transform.md)
+ [Como criar um arquivo de manifesto de um arquivo CSV](ex-csv-manifest.md)
# Transformar um conjunto de dados COCO em um formato de arquivo de manifesto
[COCO](http://cocodataset.org/#home) é um formato para especificar conjuntos de dados de detecção, segmentação e legendagem de objetos em grande escala. Este [exemplo](md-coco-transform-example.md) em Python mostra como transformar um conjunto de dados no formato de detecção de objetos COCO em [um arquivo de manifesto no formato de caixa delimitadora](md-create-manifest-file-object-detection.md) no Amazon Rekognition Custom Labels. Esta seção também inclui informações que podem ser usadas para escrever seu próprio código.
Um arquivo JSON no formato COCO consiste em cinco seções que fornecem informações para *um conjunto de dados inteiro*. Para obter mais informações, consulte [O formato de conjunto de dados COCO](md-coco-overview.md).
+ `info`: as informações gerais sobre o conjunto de dados.
+ `licenses `: informações de licença para as imagens no conjunto de dados.
+ [`images`](md-coco-overview.md#md-coco-images): uma lista de imagens no conjunto de dados.
+ [`annotations`](md-coco-overview.md#md-coco-annotations): uma lista de anotações (incluindo caixas delimitadoras) que estão presentes em todas as imagens no conjunto de dados.
+ [`categories`](md-coco-overview.md#md-coco-categories): uma lista de categorias de rótulo.
São precisas informações das listas `images`, `annotations` e `categories` para criar um arquivo de manifesto do Amazon Rekognition Custom Labels.
Um arquivo de manifesto Amazon Rekognition Custom Labels está no formato de linhas JSON, onde cada linha tem a caixa delimitadora e as informações do rótulo de um ou mais objetos *em uma imagem.* Para obter mais informações, consulte [Localização de objetos em arquivos de manifesto](md-create-manifest-file-object-detection.md).
## Como mapear objetos COCO para uma linha JSON de rótulos personalizados
Para transformar um conjunto de dados no formato COCO, você mapeia o conjunto de dados COCO para um arquivo de manifesto do Amazon Rekognition Custom Labels para localização de objetos. Para obter mais informações, consulte [Localização de objetos em arquivos de manifesto](md-create-manifest-file-object-detection.md). Para criar uma linha JSON para cada imagem, o arquivo de manifesto precisa mapear o conjunto de dados `image` COCO e o `annotation` campo do `category` objeto. IDs
Veja a seguir um exemplo de arquivo de manifesto COCO. Para obter mais informações, consulte [O formato de conjunto de dados COCO](md-coco-overview.md).
```
{
"info": {
"description": "COCO 2017 Dataset","url": "http://cocodataset.org","version": "1.0","year": 2017,"contributor": "COCO Consortium","date_created": "2017/09/01"
},
"licenses": [
{"url": "http://creativecommons.org/licenses/by/2.0/","id": 4,"name": "Attribution License"}
],
"images": [
{"id": 242287, "license": 4, "coco_url": "http://images.cocodataset.org/val2017/xxxxxxxxxxxx.jpg", "flickr_url": "http://farm3.staticflickr.com/2626/xxxxxxxxxxxx.jpg", "width": 426, "height": 640, "file_name": "xxxxxxxxx.jpg", "date_captured": "2013-11-15 02:41:42"},
{"id": 245915, "license": 4, "coco_url": "http://images.cocodataset.org/val2017/nnnnnnnnnnnn.jpg", "flickr_url": "http://farm1.staticflickr.com/88/xxxxxxxxxxxx.jpg", "width": 640, "height": 480, "file_name": "nnnnnnnnnn.jpg", "date_captured": "2013-11-18 02:53:27"}
],
"annotations": [
{"id": 125686, "category_id": 0, "iscrowd": 0, "segmentation": [[164.81, 417.51,......167.55, 410.64]], "image_id": 242287, "area": 42061.80340000001, "bbox": [19.23, 383.18, 314.5, 244.46]},
{"id": 1409619, "category_id": 0, "iscrowd": 0, "segmentation": [[376.81, 238.8,........382.74, 241.17]], "image_id": 245915, "area": 3556.2197000000015, "bbox": [399, 251, 155, 101]},
{"id": 1410165, "category_id": 1, "iscrowd": 0, "segmentation": [[486.34, 239.01,..........495.95, 244.39]], "image_id": 245915, "area": 1775.8932499999994, "bbox": [86, 65, 220, 334]}
],
"categories": [
{"supercategory": "speaker","id": 0,"name": "echo"},
{"supercategory": "speaker","id": 1,"name": "echo dot"}
]
}
```
O diagrama a seguir mostra como o conjunto de dados COCO lista para um mapa de *conjunto de dados* às linhas JSON do Amazon Rekognition Custom Labels para uma *imagem*. Cada linha JSON de uma imagem tem um campo de referência de origem, trabalho e metadados do trabalho. As cores correspondentes indicam informações para uma única imagem. Observe que, no manifesto, uma imagem individual pode ter várias anotações e metadados/categorias.
![\[Diagrama mostrando a estrutura do Coco Manifest, com imagens, anotações e categorias contidas nele.\]](http://docs.aws.amazon.com/pt_br/rekognition/latest/customlabels-dg/images/coco-transform.png)
**Para obter os objetos COCO para uma única linha JSON**
1. Para cada imagem na lista de imagens, obtenha a anotação da lista de anotações em que o valor do campo de anotação `image_id`corresponda ao campo da imagem `id`.
1. Para cada anotação correspondida na etapa 1, leia a lista `categories` e obtenha cada `category` em que o valor da `id` do campo `category` corresponda ao objeto `annotation` do campo `category_id`.
1. Crie uma linha JSON para a imagem usando os objetos `image`, `annotation` e `category` correspondentes. Para mapear os campos, consulte [Como mapear campos de objetos COCO para campos de objeto da linha JSON de rótulos personalizados](#md-mapping-fields-coco).
1. Repita as etapas de 1 a 3 até criar linhas JSON para cada objeto `image` na lista `images`.
Para obter um código de exemplo, consulte [Como transformar um conjunto de dados COCO](md-coco-transform-example.md).
## Como mapear campos de objetos COCO para campos de objeto da linha JSON de rótulos personalizados
Depois de identificar os objetos COCO para uma linha JSON do Amazon Rekognition Custom Labels, você precisa mapear os campos do objeto COCO para os respectivos campos de objeto de linha JSON do Amazon Rekognition Custom Labels. O exemplo a seguir da linha JSON do Amazon Rekognition Custom Labels mapeia uma imagem (`id`=`000000245915`) para o exemplo anterior de COCO JSON. Observe as seguintes informações:
+ `source-ref` é o local da imagem em um bucket do Amazon S3. Se suas imagens COCO não estiverem armazenadas em um bucket do Amazon S3, você precisa movê-las para um bucket do Amazon S3.
+ A lista `annotations` contém um objeto `annotation` para cada objeto na imagem. Um objeto `annotation` inclui informações da caixa delimitadora (`top`, `left`, `width`, `height`) e um identificador de rótulo (`class_id`).
+ O identificador do rótulo (`class_id`) é mapeado para a lista `class-map` nos metadados. Ele lista os rótulos usados na imagem.
```
{
"source-ref": "s3://custom-labels-bucket/images/000000245915.jpg",
"bounding-box": {
"image_size": {
"width": 640,
"height": 480,
"depth": 3
},
"annotations": [{
"class_id": 0,
"top": 251,
"left": 399,
"width": 155,
"height": 101
}, {
"class_id": 1,
"top": 65,
"left": 86,
"width": 220,
"height": 334
}]
},
"bounding-box-metadata": {
"objects": [{
"confidence": 1
}, {
"confidence": 1
}],
"class-map": {
"0": "Echo",
"1": "Echo Dot"
},
"type": "groundtruth/object-detection",
"human-annotated": "yes",
"creation-date": "2018-10-18T22:18:13.527256",
"job-name": "my job"
}
}
```
Use as informações a seguir para mapear os campos do arquivo de manifesto do Amazon Rekognition Custom Labels para os campos JSON do conjunto de dados COCO.
### source-ref
O URL do formato S3 para a localização da imagem. A imagem deve ser armazenada em um bucket do S3. Para obter mais informações, consulte [source-ref](md-create-manifest-file-object-detection.md#cd-manifest-source-ref). Se o campo COCO `coco_url` apontar para uma localização de bucket do S3, será possível usar o valor de `coco_url` para o valor de `source-ref`. Como alternativa, é possível mapear o `source-ref` para o campo `file_name` (COCO) e, em seu código de transformação, adicionar o caminho do S3 necessário ao local em que a imagem está armazenada.
### *bounding-box*
Um nome de atributo de rótulo de sua escolha. Para obter mais informações, consulte [*bounding-box*](md-create-manifest-file-object-detection.md#md-manifest-source-bounding-box).
#### image\$1size
O tamanho da imagem em pixels. Mapeia para um objeto `image` na lista de [imagens](md-coco-overview.md#md-coco-images).
+ `height`-> `image.height`
+ `width`-> `image.width`
+ `depth`-> Não é usado pelo Amazon Rekognition Custom Labels, mas um valor deve ser fornecido.
#### anotações
Uma lista dos objetos `annotation`. Há um `annotation` para cada objeto na imagem.
#### anotação
Contém informações da caixa delimitadora de uma instância de um objeto na imagem.
+ `class_id`-> mapeamento de identificação numérica para a lista de `class-map` do rótulo personalizado.
+ `top` -> `bbox[1]`
+ `left` -> `bbox[0]`
+ `width` -> `bbox[2]`
+ `height` -> `bbox[3]`
### *bounding-box*-metadados
Metadados para o atributo de rótulo. Inclui os rótulos e os identificadores dos rótulos. Para obter mais informações, consulte [*bounding-box*-metadados](md-create-manifest-file-object-detection.md#md-manifest-source-bounding-box-metadata).
#### Objetos
Uma matriz de objetos na imagem. Mapas para a lista `annotations` por índice.
##### Objeto
+ `confidence`-> Não é usado pelo Amazon Rekognition Custom Labels, mas um valor (1) é obrigatório.
#### class-map
Um mapa dos rótulos (classes) que se aplicam aos objetos detectados na imagem. Mapeia para objetos de categoria na lista de [categorias](md-coco-overview.md#md-coco-categories).
+ `id` -> `category.id`
+ `id value` -> `category.name`
#### type
Deve ser `groundtruth/object-detection`
#### human-annotated
Especifique `yes` ou `no`. Para obter mais informações, consulte [*bounding-box*-metadados](md-create-manifest-file-object-detection.md#md-manifest-source-bounding-box-metadata).
#### creation-date -> [image](md-coco-overview.md#md-coco-images).date\$1captured
A data e a hora da criação da imagem. Mapeia para o campo [imagem](md-coco-overview.md#md-coco-images) .date\$1capture de uma imagem na lista de imagens COCO. O Amazon Rekognition Custom Labels espera que o formato de `creation-date` seja *Y-M-DTH:M:S*.
#### job-name
Um nome de trabalho de sua escolha.
# O formato de conjunto de dados COCO
Um conjunto de dados COCO consiste de cinco seções de informações que fornecem informações para todo o conjunto de dados. O formato de um conjunto de dados de detecção de objetos COCO está documentado em [COCO Data Format](http://cocodataset.org/#format-data).
+ info: as informações gerais sobre o conjunto de dados.
+ licences: informações de licença para as imagens no conjunto de dados.
+ [images](#md-coco-images): uma lista de imagens no conjunto de dados.
+ [annotations](#md-coco-annotations): uma lista de anotações (incluindo caixas delimitadoras) que estão presentes em todas as imagens no conjunto de dados.
+ [categories](#md-coco-categories): uma lista de categorias de rótulo.
Para criar um manifesto de rótulos personalizados, você usa as listas `images`, `annotations` e `categories` do arquivo de manifesto COCO. As outras seções (`info`, `licences`) não são obrigatórias. Veja a seguir um exemplo de arquivo de manifesto COCO.
```
{
"info": {
"description": "COCO 2017 Dataset","url": "http://cocodataset.org","version": "1.0","year": 2017,"contributor": "COCO Consortium","date_created": "2017/09/01"
},
"licenses": [
{"url": "http://creativecommons.org/licenses/by/2.0/","id": 4,"name": "Attribution License"}
],
"images": [
{"id": 242287, "license": 4, "coco_url": "http://images.cocodataset.org/val2017/xxxxxxxxxxxx.jpg", "flickr_url": "http://farm3.staticflickr.com/2626/xxxxxxxxxxxx.jpg", "width": 426, "height": 640, "file_name": "xxxxxxxxx.jpg", "date_captured": "2013-11-15 02:41:42"},
{"id": 245915, "license": 4, "coco_url": "http://images.cocodataset.org/val2017/nnnnnnnnnnnn.jpg", "flickr_url": "http://farm1.staticflickr.com/88/xxxxxxxxxxxx.jpg", "width": 640, "height": 480, "file_name": "nnnnnnnnnn.jpg", "date_captured": "2013-11-18 02:53:27"}
],
"annotations": [
{"id": 125686, "category_id": 0, "iscrowd": 0, "segmentation": [[164.81, 417.51,......167.55, 410.64]], "image_id": 242287, "area": 42061.80340000001, "bbox": [19.23, 383.18, 314.5, 244.46]},
{"id": 1409619, "category_id": 0, "iscrowd": 0, "segmentation": [[376.81, 238.8,........382.74, 241.17]], "image_id": 245915, "area": 3556.2197000000015, "bbox": [399, 251, 155, 101]},
{"id": 1410165, "category_id": 1, "iscrowd": 0, "segmentation": [[486.34, 239.01,..........495.95, 244.39]], "image_id": 245915, "area": 1775.8932499999994, "bbox": [86, 65, 220, 334]}
],
"categories": [
{"supercategory": "speaker","id": 0,"name": "echo"},
{"supercategory": "speaker","id": 1,"name": "echo dot"}
]
}
```
## lista de imagens
As imagens referenciadas por um conjunto de dados COCO são listadas na matriz de imagens. Cada objeto de imagem contém informações sobre a imagem, como o nome do arquivo da imagem. No exemplo de objeto de imagem a seguir, observe as seguintes informações e quais campos são necessários para criar um arquivo de manifesto Amazon Rekognition Custom Labels.
+ `id`: (obrigatório) um identificador exclusivo para a imagem. O campo `id` mapeia para o campo `id` na matriz de anotações (onde as informações da caixa delimitadora são armazenadas).
+ `license`: (não obrigatória) mapeia para a matriz de licenças.
+ `coco_url`: (opcional) o local da imagem.
+ `flickr_url`: (não obrigatório) o local da imagem no Flickr.
+ `width`: (obrigatório) a largura da imagem.
+ `height`: (obrigatório) a altura da imagem.
+ `file_name`: (obrigatório) o nome do arquivo de imagem. Neste exemplo, `file_name` e `id` combinam, mas não é um requisito para conjuntos de dados COCO.
+ `date_captured`: (obrigatória) a data e a hora em que a imagem foi capturada.
```
{
"id": 245915,
"license": 4,
"coco_url": "http://images.cocodataset.org/val2017/nnnnnnnnnnnn.jpg",
"flickr_url": "http://farm1.staticflickr.com/88/nnnnnnnnnnnnnnnnnnn.jpg",
"width": 640,
"height": 480,
"file_name": "000000245915.jpg",
"date_captured": "2013-11-18 02:53:27"
}
```
## lista de anotações (caixas delimitadoras)
As informações da caixa delimitadora de todos os objetos em todas as imagens são armazenadas na lista de anotações. Um único objeto de anotação contém informações da caixa delimitadora de um único objeto e o rótulo do objeto em uma imagem. Há um objeto de anotação para cada instância de um objeto em uma imagem.
No exemplo a seguir, observe as seguintes informações e quais campos são necessários para criar um arquivo de manifesto Amazon Rekognition Custom Labels.
+ `id`: (não obrigatório) o identificador da anotação.
+ `image_id`: (obrigatório) corresponde ao `id` da imagem na matriz de imagens.
+ `category_id`: (obrigatório) o identificador da etiqueta que identifica o objeto dentro de uma caixa delimitadora. Ele mapeia para o campo `id` da matriz de categorias.
+ `iscrowd`: (não obrigatório) especifica se a imagem contém uma multidão de objetos.
+ `segmentation`: (não obrigatória) informações de segmentação de objetos em uma imagem. O Amazon Rekognition Custom Labels não é compatível com a segmentação.
+ `area`: (não obrigatória) a área da anotação.
+ `bbox`: (obrigatório) contém as coordenadas, em pixels, de uma caixa delimitadora ao redor de um objeto na imagem.
```
{
"id": 1409619,
"category_id": 1,
"iscrowd": 0,
"segmentation": [
[86.0, 238.8,..........382.74, 241.17]
],
"image_id": 245915,
"area": 3556.2197000000015,
"bbox": [86, 65, 220, 334]
}
```
## lista de categorias
As informações do rótulo são armazenadas na matriz de categorias. No exemplo de objeto de categoria a seguir, observe as seguintes informações e quais campos são necessários para criar um arquivo de manifesto Amazon Rekognition Custom Labels.
+ `supercategory`: (não obrigatória) a categoria principal de uma etiqueta.
+ `id`: (obrigatório) o identificador da etiqueta. O campo `id` mapeia para o campo `category_id` em um objeto `annotation`. No exemplo a seguir, o identificador de um ponto de eco é 2.
+ `name`: (obrigatório) o nome do rótulo.
```
{"supercategory": "speaker","id": 2,"name": "echo dot"}
```
# Como transformar um conjunto de dados COCO
Use o exemplo em Python a seguir para transformar informações de caixa delimitadora de um conjunto de dados no formato COCO em um arquivo de manifesto no Amazon Rekognition Custom Labels. O código faz upload do arquivo de manifesto criado para o bucket do Amazon S3. O código também fornece um comando da AWS CLI que é possível usar para fazer upload de suas imagens.
**Para transformar um conjunto de dados COCO (SDK)**
1. Se ainda não tiver feito isso:
1. Certifique-se de que você tem as permissões `AmazonS3FullAccess`. Para obter mais informações, consulte [Configurar permissões do SDK](su-sdk-permissions.md).
1. Instale e configure o AWS CLI e AWS SDKs o. Para obter mais informações, consulte [Etapa 4: configurar o AWS CLI e AWS SDKs](su-awscli-sdk.md).
1. Use o código em Python a seguir para transformar um conjunto de dados COCO. Defina os seguintes valores:
+ `s3_bucket`: o nome do bucket do S3 no qual você deseja armazenar as imagens e o arquivo de manifesto do Amazon Rekognition Custom Labels.
+ `s3_key_path_images`: o caminho para onde você deseja colocar as imagens no bucket do S3 (`s3_bucket`).
+ `s3_key_path_manifest_file`: o caminho para onde você deseja colocar o arquivo de manifesto de rótulos personalizados no bucket do S3 (`s3_bucket`).
+ `local_path`: o caminho local para onde o exemplo abre o conjunto de dados COCO de entrada e também salva o novo arquivo de manifesto do Custom Labels.
+ `local_images_path`: o caminho local para as imagens que você deseja usar para treinamento.
+ `coco_manifest`: o nome do arquivo do conjunto de dados COCO de entrada.
+ `cl_manifest_file`: um nome para o arquivo de manifesto criado pelo exemplo. O arquivo é salvo no local especificado por `local_path`. Por convenção, o arquivo tem a extensão `.manifest`, mas isso não é obrigatório.
+ `job_name`: um nome para o trabalho de rótulos personalizados.
```
import json
import os
import random
import shutil
import datetime
import botocore
import boto3
import PIL.Image as Image
import io
#S3 location for images
s3_bucket = 'bucket'
s3_key_path_manifest_file = 'path to custom labels manifest file/'
s3_key_path_images = 'path to images/'
s3_path='s3://' + s3_bucket + '/' + s3_key_path_images
s3 = boto3.resource('s3')
#Local file information
local_path='path to input COCO dataset and output Custom Labels manifest/'
local_images_path='path to COCO images/'
coco_manifest = 'COCO dataset JSON file name'
coco_json_file = local_path + coco_manifest
job_name='Custom Labels job name'
cl_manifest_file = 'custom_labels.manifest'
label_attribute ='bounding-box'
open(local_path + cl_manifest_file, 'w').close()
# class representing a Custom Label JSON line for an image
class cl_json_line:
def __init__(self,job, img):
#Get image info. Annotations are dealt with seperately
sizes=[]
image_size={}
image_size["width"] = img["width"]
image_size["depth"] = 3
image_size["height"] = img["height"]
sizes.append(image_size)
bounding_box={}
bounding_box["annotations"] = []
bounding_box["image_size"] = sizes
self.__dict__["source-ref"] = s3_path + img['file_name']
self.__dict__[job] = bounding_box
#get metadata
metadata = {}
metadata['job-name'] = job_name
metadata['class-map'] = {}
metadata['human-annotated']='yes'
metadata['objects'] = []
date_time_obj = datetime.datetime.strptime(img['date_captured'], '%Y-%m-%d %H:%M:%S')
metadata['creation-date']= date_time_obj.strftime('%Y-%m-%dT%H:%M:%S')
metadata['type']='groundtruth/object-detection'
self.__dict__[job + '-metadata'] = metadata
print("Getting image, annotations, and categories from COCO file...")
with open(coco_json_file) as f:
#Get custom label compatible info
js = json.load(f)
images = js['images']
categories = js['categories']
annotations = js['annotations']
print('Images: ' + str(len(images)))
print('annotations: ' + str(len(annotations)))
print('categories: ' + str(len (categories)))
print("Creating CL JSON lines...")
images_dict = {image['id']: cl_json_line(label_attribute, image) for image in images}
print('Parsing annotations...')
for annotation in annotations:
image=images_dict[annotation['image_id']]
cl_annotation = {}
cl_class_map={}
# get bounding box information
cl_bounding_box={}
cl_bounding_box['left'] = annotation['bbox'][0]
cl_bounding_box['top'] = annotation['bbox'][1]
cl_bounding_box['width'] = annotation['bbox'][2]
cl_bounding_box['height'] = annotation['bbox'][3]
cl_bounding_box['class_id'] = annotation['category_id']
getattr(image, label_attribute)['annotations'].append(cl_bounding_box)
for category in categories:
if annotation['category_id'] == category['id']:
getattr(image, label_attribute + '-metadata')['class-map'][category['id']]=category['name']
cl_object={}
cl_object['confidence'] = int(1) #not currently used by Custom Labels
getattr(image, label_attribute + '-metadata')['objects'].append(cl_object)
print('Done parsing annotations')
# Create manifest file.
print('Writing Custom Labels manifest...')
for im in images_dict.values():
with open(local_path+cl_manifest_file, 'a+') as outfile:
json.dump(im.__dict__,outfile)
outfile.write('\n')
outfile.close()
# Upload manifest file to S3 bucket.
print ('Uploading Custom Labels manifest file to S3 bucket')
print('Uploading' + local_path + cl_manifest_file + ' to ' + s3_key_path_manifest_file)
print(s3_bucket)
s3 = boto3.resource('s3')
s3.Bucket(s3_bucket).upload_file(local_path + cl_manifest_file, s3_key_path_manifest_file + cl_manifest_file)
# Print S3 URL to manifest file,
print ('S3 URL Path to manifest file. ')
print('\033[1m s3://' + s3_bucket + '/' + s3_key_path_manifest_file + cl_manifest_file + '\033[0m')
# Display aws s3 sync command.
print ('\nAWS CLI s3 sync command to upload your images to S3 bucket. ')
print ('\033[1m aws s3 sync ' + local_images_path + ' ' + s3_path + '\033[0m')
```
1. Execute o código.
1. Na saída do programa, observe o comando `s3 sync`. Você precisa dele na próxima etapa.
1. No prompt de comando, execute o comando `s3 sync`. Suas imagens são carregadas para o bucket do S3. Se o comando falhar durante o upload, execute-o novamente até que suas imagens locais estejam sincronizadas com o bucket do S3.
1. Na saída do programa, observe o caminho do URL do S3 para o arquivo de manifesto. Você precisa dele na próxima etapa.
1. Siga a instrução em [Criação de um conjunto de dados com um arquivo de manifesto do SageMaker AI Ground Truth (console)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console) para criar um conjunto de dados com o arquivo de manifesto carregado. Para a etapa 8, na **localização do arquivo .manifest**, insira a URL do Amazon S3 que você observou na etapa anterior. Se estiver usando o AWS SDK, use [Criação de um conjunto de dados com um arquivo de manifesto (SDK) do SageMaker AI Ground Truth](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk).
# Transformando arquivos de manifesto com vários rótulos do SageMaker AI Ground Truth
Este tópico mostra como transformar um arquivo de manifesto com vários rótulos do Amazon SageMaker AI Ground Truth em um arquivo de manifesto no formato Amazon Rekognition Custom Labels.
SageMaker Os arquivos de manifesto do AI Ground Truth para trabalhos com vários rótulos são formatados de forma diferente dos arquivos de manifesto no formato Amazon Rekognition Custom Labels. A classificação com vários rótulos ocorre quando uma imagem é classificada em um conjunto de classes, mas pode pertencer a várias classes ao mesmo tempo. Neste caso, a imagem pode ter potencialmente vários rótulos (vários rótulos), como *futebol* e *bola*.
Para obter informações sobre trabalhos com vários rótulos do SageMaker AI Ground Truth, consulte [Classificação de imagens (vários rótulos](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-image-classification-multilabel.html)). Para obter informações sobre os arquivos de manifesto do Amazon Rekognition Custom Labels em formato de vários rótulos, consulte [Como adicionar vários rótulos em nível de imagem a uma imagem](md-create-manifest-file-classification.md#md-dataset-purpose-classification-multiple-labels).
## Obtendo o arquivo de manifesto para um trabalho do SageMaker AI Ground Truth
O procedimento a seguir mostra como obter o arquivo manifesto de saída (`output.manifest`) para um trabalho do Amazon SageMaker AI Ground Truth. `output.manifest` será usado como entrada para o próximo procedimento.
**Para baixar um arquivo de manifesto de trabalho do SageMaker AI Ground Truth**
1. Abra a [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. No painel de navegação, escolha **Ground Truth** e escolha **Labeling Jobs**.
1. Escolha o trabalho de rotulagem que contém o arquivo de manifesto que você deseja usar.
1. Na página de detalhes, escolha o link em **Local do conjunto de dados de saída**. O console do Amazon S3 é aberto no local do conjunto de dados.
1. Escolha `Manifests`, `output` e depois `output.manifest`.
1. Escolha **Ações de objeto** e escolha **Download** para baixar o arquivo de manifesto.
## Transformação de um arquivo de manifesto de SageMaker IA com vários rótulos
O procedimento a seguir cria um arquivo de manifesto Amazon Rekognition Custom Labels no formato de vários rótulos a partir de um arquivo de manifesto AI existente no formato de vários rótulos. SageMaker GroundTruth
**nota**
Para executar o código, você precisa do Python versão 3 ou superior.
**Para transformar um arquivo de manifesto de SageMaker IA com vários rótulos**
1. Execute o código em Python a seguir. Forneça o nome do arquivo de manifesto criado em [Obtendo o arquivo de manifesto para um trabalho do SageMaker AI Ground Truth](#md-get-gt-manifest) como um argumento da linha de comando.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Purpose
Shows how to create and Amazon Rekognition Custom Labels format
manifest file from an Amazon SageMaker Ground Truth Image
Classification (Multi-label) format manifest file.
"""
import json
import logging
import argparse
import os.path
logger = logging.getLogger(__name__)
def create_manifest_file(ground_truth_manifest_file):
"""
Creates an Amazon Rekognition Custom Labels format manifest file from
an Amazon SageMaker Ground Truth Image Classification (Multi-label) format
manifest file.
:param: ground_truth_manifest_file: The name of the Ground Truth manifest file,
including the relative path.
:return: The name of the new Custom Labels manifest file.
"""
logger.info('Creating manifest file from %s', ground_truth_manifest_file)
new_manifest_file = f'custom_labels_{os.path.basename(ground_truth_manifest_file)}'
# Read the SageMaker Ground Truth manifest file into memory.
with open(ground_truth_manifest_file) as gt_file:
lines = gt_file.readlines()
#Iterate through the lines one at a time to generate the
#new lines for the Custom Labels manifest file.
with open(new_manifest_file, 'w') as the_new_file:
for line in lines:
#job_name - The of the Amazon Sagemaker Ground Truth job.
job_name = ''
# Load in the old json item from the Ground Truth manifest file
old_json = json.loads(line)
# Get the job name
keys = old_json.keys()
for key in keys:
if 'source-ref' not in key and '-metadata' not in key:
job_name = key
new_json = {}
# Set the location of the image
new_json['source-ref'] = old_json['source-ref']
# Temporarily store the list of labels
labels = old_json[job_name]
# Iterate through the labels and reformat to Custom Labels format
for index, label in enumerate(labels):
new_json[f'{job_name}{index}'] = index
metadata = {}
metadata['class-name'] = old_json[f'{job_name}-metadata']['class-map'][str(label)]
metadata['confidence'] = old_json[f'{job_name}-metadata']['confidence-map'][str(label)]
metadata['type'] = 'groundtruth/image-classification'
metadata['job-name'] = old_json[f'{job_name}-metadata']['job-name']
metadata['human-annotated'] = old_json[f'{job_name}-metadata']['human-annotated']
metadata['creation-date'] = old_json[f'{job_name}-metadata']['creation-date']
# Add the metadata to new json line
new_json[f'{job_name}{index}-metadata'] = metadata
# Write the current line to the json file
the_new_file.write(json.dumps(new_json))
the_new_file.write('\n')
logger.info('Created %s', new_manifest_file)
return new_manifest_file
def add_arguments(parser):
"""
Adds command line arguments to the parser.
:param parser: The command line parser.
"""
parser.add_argument(
"manifest_file", help="The Amazon SageMaker Ground Truth manifest file"
"that you want to use."
)
def main():
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
try:
# get command line arguments
parser = argparse.ArgumentParser(usage=argparse.SUPPRESS)
add_arguments(parser)
args = parser.parse_args()
# Create the manifest file
manifest_file = create_manifest_file(args.manifest_file)
print(f'Manifest file created: {manifest_file}')
except FileNotFoundError as err:
logger.exception('File not found: %s', err)
print(f'File not found: {err}. Check your manifest file.')
if __name__ == "__main__":
main()
```
1. Observe o nome do novo arquivo de manifesto exibido pelo script. Ele será usado na próxima etapa.
1. [Faça upload dos arquivos de manifesto](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) para o bucket do Amazon S3 que você deseja usar para armazenar o arquivo de manifesto.
**nota**
Certifique-se de que o Amazon Rekognition Custom Labels tenha acesso ao bucket do Amazon S3 referenciado no campo `source-ref` das linhas JSON do arquivo de manifesto. Para obter mais informações, consulte [Como acessar os buckets externos do Amazon S3](su-console-policy.md#su-external-buckets). Se seu trabalho do Ground Truth armazena imagens no bucket do console do Amazon Rekognition Custom Labels, você não precisa adicionar permissões.
1. Siga as instruções em [Criação de um conjunto de dados com um arquivo de manifesto do SageMaker AI Ground Truth (console)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console) para criar um conjunto de dados com o arquivo de manifesto carregado. Para a etapa 8, na **localização do arquivo .manifest**, insira a URL do Amazon S3 para a localização do arquivo de manifesto. Se estiver usando o AWS SDK, use [Criação de um conjunto de dados com um arquivo de manifesto (SDK) do SageMaker AI Ground Truth](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk).
# Como criar um arquivo de manifesto de um arquivo CSV
Este exemplo de script em Python simplifica a criação de um arquivo de manifesto usando um arquivo de valores separados por vírgulas (CSV) para rotular imagens. Crie o arquivo CSV. O arquivo de manifesto é adequado para a [classificação de imagens com vários rótulos](getting-started.md#gs-multi-label-image-classification-example) ou [Classificação de imagens com vários rótulos](getting-started.md#gs-multi-label-image-classification-example). Para obter mais informações, consulte [Encontre objetos, cenas e conceitos](understanding-custom-labels.md#tm-classification).
**nota**
Este script não cria um arquivo de manifesto adequado para descobrir [localizações de objetos](understanding-custom-labels.md#tm-object-localization) ou para encontrar [localizações de marcas](understanding-custom-labels.md#tm-brand-detection-localization).
Um arquivo de manifesto descreve as imagens usadas para treinar um modelo. Por exemplo, localizações de imagens e rótulos atribuídos às imagens. Um arquivo de manifesto é composto por uma ou mais linhas JSON. Cada linha JSON descreve uma única imagem. Para obter mais informações, consulte [Importar rótulos ao nível da imagem em arquivos de manifesto](md-create-manifest-file-classification.md).
Um arquivo CSV representa dados tabulares em várias linhas em um arquivo de texto. Os campos em uma linha são separados por vírgulas. Para obter mais informações, consulte [valores separados por vírgula](https://en.wikipedia.org/wiki/Comma-separated_values). Para esse script, cada linha em seu arquivo CSV representa uma única imagem e mapeia para uma linha JSON no arquivo de manifesto. Para criar um arquivo CSV para um arquivo de manifesto que seja compatível com a [classificação de imagens com vários rótulos](getting-started.md#gs-multi-label-image-classification-example), adicione um ou mais rótulos em nível de imagem a cada linha. Para criar um arquivo de manifesto adequado para [Classificação de imagens](getting-started.md#gs-image-classification-example), adicione um único rótulo em nível de imagem a cada linha.
Por exemplo, o arquivo CSV a seguir descreve as imagens no projeto [Classificação de imagens com vários rótulos](getting-started.md#gs-multi-label-image-classification-example) (Flores) *Conceitos básicos*.
```
camellia1.jpg,camellia,with_leaves
camellia2.jpg,camellia,with_leaves
camellia3.jpg,camellia,without_leaves
helleborus1.jpg,helleborus,without_leaves,not_fully_grown
helleborus2.jpg,helleborus,with_leaves,fully_grown
helleborus3.jpg,helleborus,with_leaves,fully_grown
jonquil1.jpg,jonquil,with_leaves
jonquil2.jpg,jonquil,with_leaves
jonquil3.jpg,jonquil,with_leaves
jonquil4.jpg,jonquil,without_leaves
mauve_honey_myrtle1.jpg,mauve_honey_myrtle,without_leaves
mauve_honey_myrtle2.jpg,mauve_honey_myrtle,with_leaves
mauve_honey_myrtle3.jpg,mauve_honey_myrtle,with_leaves
mediterranean_spurge1.jpg,mediterranean_spurge,with_leaves
mediterranean_spurge2.jpg,mediterranean_spurge,without_leaves
```
O script gera linhas JSON para cada linha. Por exemplo, a seguir está a linha JSON para a primeira linha (`camellia1.jpg,camellia,with_leaves`).
```
{"source-ref": "s3://bucket/flowers/train/camellia1.jpg","camellia": 1,"camellia-metadata":{"confidence": 1,"job-name": "labeling-job/camellia","class-name": "camellia","human-annotated": "yes","creation-date": "2022-01-21T14:21:05","type": "groundtruth/image-classification"},"with_leaves": 1,"with_leaves-metadata":{"confidence": 1,"job-name": "labeling-job/with_leaves","class-name": "with_leaves","human-annotated": "yes","creation-date": "2022-01-21T14:21:05","type": "groundtruth/image-classification"}}
```
No exemplo CSV, o caminho do Amazon S3 para a imagem não está presente. Se seu arquivo CSV não incluir o caminho do Amazon S3 para as imagens, use o argumento da linha de comando `--s3_path` para especificar o caminho do Amazon S3 para a imagem.
O script registra a primeira entrada de cada imagem em um arquivo CSV de imagem desduplicada. O arquivo CSV de imagem desduplicada contém uma única instância de cada imagem encontrada no arquivo CSV de entrada. Outras ocorrências de uma imagem no arquivo CSV de entrada são registradas em um arquivo CSV de imagem duplicado. Se o script encontrar imagens duplicadas, revise o arquivo CSV de imagem duplicada e atualize o arquivo CSV de imagem desduplicada conforme necessário. Execute novamente o script com o arquivo desduplicado. Se nenhuma duplicata for encontrada no arquivo CSV de entrada, o script excluirá o arquivo CSV de imagem desduplicada e a imagem duplicada, pois eles estão vazios. CSVfile
Neste procedimento, o arquivo CSV é criado e o script em Python é executado para criar o arquivo de manifesto.
**Para criar um arquivo de manifesto de um arquivo CSV**
1. Crie um arquivo CSV com os seguintes campos em cada linha (uma linha por imagem). Não adicione uma linha de cabeçalho ao arquivo CSV.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/rekognition/latest/customlabels-dg/ex-csv-manifest.html)
Por exemplo, `camellia1.jpg,camellia,with_leaves` ou `s3://my-bucket/flowers/train/camellia1.jpg,camellia,with_leaves`
1. Salve o arquivo CSV.
1. Execute o seguinte script em Python. Forneça os seguintes argumentos:
+ `csv_file`: o arquivo CSV que você criou na etapa 1.
+ `manifest_file`: o nome do arquivo de manifesto que você deseja criar.
+ (Opcional) `--s3_path s3://path_to_folder/`: o caminho do Amazon S3 a ser adicionado aos nomes dos arquivos de imagem (campo 1). Use `--s3_path` se as imagens no campo 1 ainda não contiverem um caminho do S3.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
from datetime import datetime, timezone
import argparse
import logging
import csv
import os
import json
"""
Purpose
Amazon Rekognition Custom Labels model example used in the service documentation.
Shows how to create an image-level (classification) manifest file from a CSV file.
You can specify multiple image level labels per image.
CSV file format is
image,label,label,..
If necessary, use the bucket argument to specify the S3 bucket folder for the images.
https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/md-gt-cl-transform.html
"""
logger = logging.getLogger(__name__)
def check_duplicates(csv_file, deduplicated_file, duplicates_file):
"""
Checks for duplicate images in a CSV file. If duplicate images
are found, deduplicated_file is the deduplicated CSV file - only the first
occurence of a duplicate is recorded. Other duplicates are recorded in duplicates_file.
:param csv_file: The source CSV file.
:param deduplicated_file: The deduplicated CSV file to create. If no duplicates are found
this file is removed.
:param duplicates_file: The duplicate images CSV file to create. If no duplicates are found
this file is removed.
:return: True if duplicates are found, otherwise false.
"""
logger.info("Deduplicating %s", csv_file)
duplicates_found = False
# Find duplicates.
with open(csv_file, 'r', newline='', encoding="UTF-8") as f,\
open(deduplicated_file, 'w', encoding="UTF-8") as dedup,\
open(duplicates_file, 'w', encoding="UTF-8") as duplicates:
reader = csv.reader(f, delimiter=',')
dedup_writer = csv.writer(dedup)
duplicates_writer = csv.writer(duplicates)
entries = set()
for row in reader:
# Skip empty lines.
if not ''.join(row).strip():
continue
key = row[0]
if key not in entries:
dedup_writer.writerow(row)
entries.add(key)
else:
duplicates_writer.writerow(row)
duplicates_found = True
if duplicates_found:
logger.info("Duplicates found check %s", duplicates_file)
else:
os.remove(duplicates_file)
os.remove(deduplicated_file)
return duplicates_found
def create_manifest_file(csv_file, manifest_file, s3_path):
"""
Reads a CSV file and creates a Custom Labels classification manifest file.
:param csv_file: The source CSV file.
:param manifest_file: The name of the manifest file to create.
:param s3_path: The S3 path to the folder that contains the images.
"""
logger.info("Processing CSV file %s", csv_file)
image_count = 0
label_count = 0
with open(csv_file, newline='', encoding="UTF-8") as csvfile,\
open(manifest_file, "w", encoding="UTF-8") as output_file:
image_classifications = csv.reader(
csvfile, delimiter=',', quotechar='|')
# Process each row (image) in CSV file.
for row in image_classifications:
source_ref = str(s3_path)+row[0]
image_count += 1
# Create JSON for image source ref.
json_line = {}
json_line['source-ref'] = source_ref
# Process each image level label.
for index in range(1, len(row)):
image_level_label = row[index]
# Skip empty columns.
if image_level_label == '':
continue
label_count += 1
# Create the JSON line metadata.
json_line[image_level_label] = 1
metadata = {}
metadata['confidence'] = 1
metadata['job-name'] = 'labeling-job/' + image_level_label
metadata['class-name'] = image_level_label
metadata['human-annotated'] = "yes"
metadata['creation-date'] = \
datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')
metadata['type'] = "groundtruth/image-classification"
json_line[f'{image_level_label}-metadata'] = metadata
# Write the image JSON Line.
output_file.write(json.dumps(json_line))
output_file.write('\n')
output_file.close()
logger.info("Finished creating manifest file %s\nImages: %s\nLabels: %s",
manifest_file, image_count, label_count)
return image_count, label_count
def add_arguments(parser):
"""
Adds command line arguments to the parser.
:param parser: The command line parser.
"""
parser.add_argument(
"csv_file", help="The CSV file that you want to process."
)
parser.add_argument(
"--s3_path", help="The S3 bucket and folder path for the images."
" If not supplied, column 1 is assumed to include the S3 path.", required=False
)
def main():
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
try:
# Get command line arguments
parser = argparse.ArgumentParser(usage=argparse.SUPPRESS)
add_arguments(parser)
args = parser.parse_args()
s3_path = args.s3_path
if s3_path is None:
s3_path = ''
# Create file names.
csv_file = args.csv_file
file_name = os.path.splitext(csv_file)[0]
manifest_file = f'{file_name}.manifest'
duplicates_file = f'{file_name}-duplicates.csv'
deduplicated_file = f'{file_name}-deduplicated.csv'
# Create manifest file, if there are no duplicate images.
if check_duplicates(csv_file, deduplicated_file, duplicates_file):
print(f"Duplicates found. Use {duplicates_file} to view duplicates "
f"and then update {deduplicated_file}. ")
print(f"{deduplicated_file} contains the first occurence of a duplicate. "
"Update as necessary with the correct label information.")
print(f"Re-run the script with {deduplicated_file}")
else:
print("No duplicates found. Creating manifest file.")
image_count, label_count = create_manifest_file(csv_file,
manifest_file,
s3_path)
print(f"Finished creating manifest file: {manifest_file} \n"
f"Images: {image_count}\nLabels: {label_count}")
except FileNotFoundError as err:
logger.exception("File not found: %s", err)
print(f"File not found: {err}. Check your input CSV file.")
if __name__ == "__main__":
main()
```
1. Se planeja usar um conjunto de dados de teste, repita as etapas de 1 a 3 para criar um arquivo de manifesto para seu conjunto de dados de teste.
1. Se necessário, copie as imagens para o caminho do bucket do Amazon S3 que você especificou na coluna 1 do arquivo CSV (ou especificado na linha de comando `--s3_path`). É possível usar o seguinte comando AWS do S3.
```
aws s3 cp --recursive your-local-folder s3://your-target-S3-location
```
1. [Faça upload dos arquivos de manifesto](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) para o bucket do Amazon S3 que você deseja usar para armazenar o arquivo de manifesto.
**nota**
Certifique-se de que o Amazon Rekognition Custom Labels tenha acesso ao bucket do Amazon S3 referenciado no campo `source-ref` das linhas JSON do arquivo de manifesto. Para obter mais informações, consulte [Como acessar os buckets externos do Amazon S3](su-console-policy.md#su-external-buckets). Se seu trabalho do Ground Truth armazena imagens no bucket do console do Amazon Rekognition Custom Labels, você não precisa adicionar permissões.
1. Siga as instruções em [Criação de um conjunto de dados com um arquivo de manifesto do SageMaker AI Ground Truth (console)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console) para criar um conjunto de dados com o arquivo de manifesto carregado. Para a etapa 8, na **localização do arquivo .manifest**, insira a URL do Amazon S3 para a localização do arquivo de manifesto. Se estiver usando o AWS SDK, use [Criação de um conjunto de dados com um arquivo de manifesto (SDK) do SageMaker AI Ground Truth](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk).
# Copiar conteúdo de um conjunto de dados existente
Se já criou um conjunto de dados, pode copiar seu conteúdo para um novo conjunto de dados. Para criar um conjunto de dados a partir de um conjunto de dados existente com o AWS SDK, consulte. [Como criar um conjunto de dados usando um conjunto de dados existente (SDK)](md-create-dataset-existing-dataset-sdk.md)
**Para criar um conjunto de dados usando um conjunto de dados personalizados do Amazon Rekognition Custom Labels (console)**
1. Abra o console do Amazon Rekognition em. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Escolha **Usar rótulos personalizados**.
1. Escolha **Comece a usar**.
1. No painel de navegação esquerdo, selecione **Projetos**.
1. Na página **Projetos**, selecione o projeto ao qual você deseja adicionar um conjunto de dados. A página de detalhes do seu projeto é exibida.
1. Escolha **Criar conjunto de dados**. A página **Criar conjunto de dados** é exibida.
1. Em **Configuração inicial**, escolha **Iniciar com um único conjunto de dados** ou **Iniciar com um conjunto de dados de treinamento**. Para criar um modelo de maior qualidade, recomendamos começar com conjuntos de dados de treinamento e teste separados.
------
#### [ Single dataset ]
1. Na seção **Detalhes do conjunto de dados de treinamento**, escolha **Copiar um conjunto de dados existente do Amazon Rekognition Custom Labels**.
1. Na seção **Detalhes do conjunto de dados de treinamento**, na caixa de edição **Conjunto de dados**, digite ou selecione o nome do conjunto de dados que você deseja copiar.
1. Escolha **Criar conjunto de dados**. A página de conjuntos de dados do seu projeto é aberta.
------
#### [ Separate training and test datasets ]
1. Na seção **Detalhes do conjunto de dados de treinamento**, escolha **Copiar um conjunto de dados existente do Amazon Rekognition Custom Labels**.
1. Na seção **Detalhes do conjunto de dados de treinamento**, na caixa de edição **Conjunto de dados**, digite ou selecione o nome do conjunto de dados que você deseja copiar.
1. Na seção **Detalhes do conjunto de dados de teste**, escolha **Copiar um conjunto de dados existente do Amazon Rekognition Custom Labels**.
1. Na seção **Detalhes do conjunto de dados de teste**, na caixa de edição **Conjunto de dados**, digite ou selecione o nome do conjunto de dados que você deseja copiar.
**nota**
Seus conjuntos de dados de treinamento e teste podem ter fontes de imagem diferentes.
1. Escolha **Criar conjuntos de dados**. A página de conjuntos de dados do seu projeto é aberta.
------
1. Se precisar adicionar ou alterar rótulos, faça [Rotulagem de imagens](md-labeling-images.md).
1. Siga as etapas em [Como treinar um modelo (console)](training-model.md#tm-console) para treinar seu modelo.