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 gerenciar conjuntos de dados
Um conjunto de dados contém as imagens e os rótulos atribuídos que você usa para treinar ou testar um modelo. Os tópicos desta seção mostram como gerenciar um conjunto de dados com o console Amazon Rekognition Custom Labels e o SDK. AWS
**Topics**
+ [Como adicionar um conjunto de dados a um projeto](md-add-dataset.md)
+ [Como adicionar mais imagens a um conjunto de dados](md-add-images.md)
+ [Como criar um conjunto de dados usando um conjunto de dados existente (SDK)](md-create-dataset-existing-dataset-sdk.md)
+ [Como descrever um conjunto de dados (SDK)](md-describing-dataset-sdk.md)
+ [Como listar entradas do conjunto de dados (SDK)](md-listing-dataset-entries-sdk.md)
+ [Como distribuir um conjunto de dados de treinamento (SDK)](md-distributing-datasets.md)
+ [Como excluir um conjunto de dados](md-delete-dataset.md)
# Como adicionar um conjunto de dados a um projeto
É possível adicionar um conjunto de dados de treinamento ou teste a um projeto existente. Se quiser substituir um conjunto de dados existente, primeiro exclua o conjunto de dados existente. Para obter mais informações, consulte [Como excluir um conjunto de dados](md-delete-dataset.md). Em seguida, adicione o novo conjunto de dados.
**Topics**
+ [Como adicionar um conjunto de dados a um projeto (console)](#md-add-dataset-console)
+ [Como adicionar um conjunto de dados a um projeto (SDK)](#md-add-dataset-sdk)
## Como adicionar um conjunto de dados a um projeto (console)
É possível adicionar um conjunto de dados de treinamento ou teste a um projeto usando o console do Amazon Rekognition Custom Labels.
**Para adicionar um conjunto de dados a um projeto**
1. Abra o console do Amazon Rekognition em. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. No painel esquerdo, escolha **Usar rótulos personalizados**. A página inicial do Amazon Rekognition Custom Labels é exibida.
1. No painel de navegação esquerdo, selecione **Projetos**. A visualização Projetos é exibida.
1. Escolha o projeto ao qual você deseja adicionar um conjunto de dados.
1. No painel de navegação esquerdo, abaixo do nome do projeto, escolha **Conjuntos de dados**.
1. Se o projeto não tiver um conjunto de dados existente, a página **Criar conjunto de dados** será exibida. Faça o seguinte:
1. Na página **Criar conjunto de dados**, insira as informações da fonte da imagem. Para obter mais informações, consulte [Como criar conjuntos de dados de treinamento e teste com imagens](md-create-dataset.md).
1. Escolha **Criar conjunto de dados** para criar o conjunto de dados.
1. Se o projeto tiver um conjunto de dados existente (treinamento ou teste), a página de detalhes do projeto será exibida. Faça o seguinte:
1. Na página de detalhes do projeto, escolha **Ações**.
1. Se quiser adicionar um conjunto de dados de treinamento, escolha **Criar conjunto de dados de teste**.
1. Se quiser adicionar um conjunto de dados de teste, escolha **Criar conjunto de dados de teste**.
1. Na página **Criar conjunto de dados**, insira as informações da fonte da imagem. Para obter mais informações, consulte [Como criar conjuntos de dados de treinamento e teste com imagens](md-create-dataset.md).
1. Escolha **Criar conjunto de dados** para criar o conjunto de dados.
1. Adicione imagens ao seu conjunto de dados. Para obter mais informações, consulte [Como adicionar mais imagens (console)](md-add-images.md#md-add-images-console).
1. Adicione rótulos ao seu conjunto de dados. Para obter mais informações, consulte [Adicionar novos rótulos (console)](md-labels.md#md-add-new-labels).
1. Adicione rótulos às suas imagens. Se estiver adicionando rótulos em nível de imagem, consulte [Como atribuir rótulos em nível de imagem em uma imagem](md-assign-image-level-labels.md). Se estiver adicionando caixas delimitadoras, consulte [Como rotular objetos com caixas delimitadoras](md-localize-objects.md). Para obter mais informações, consulte [Como definir os conjuntos de dados](md-dataset-purpose.md).
## Como adicionar um conjunto de dados a um projeto (SDK)
É possível adicionar um conjunto de dados de treinamento ou teste a um projeto existente das seguintes maneiras:
+ Criar um conjunto de dados usando um arquivo de manifesto. Para obter mais informações, 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).
+ Crie um conjunto de dados vazio e preencha o conjunto de dados depois. O exemplo a seguir mostra como criar um conjunto de dados vazio. Para adicionar entradas depois de criar um conjunto de dados vazio, consulte [Como adicionar mais imagens a um conjunto de dados](md-add-images.md).
**Topics**
**Para adicionar um conjunto de dados a um projeto (SDK)**
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. Use os exemplos a seguir para adicionar linhas JSON a um conjunto de dados.
------
#### [ CLI ]
Substitua `project_arn` pelo projeto ao qual deseja adicionar o conjunto de dados. Substitua `dataset_type` por `TRAIN` para criar um conjunto de dados de treinamento ou `TEST` para criar um conjunto de dados de teste.
```
aws rekognition create-dataset --project-arn project_arn \
--dataset-type dataset_type \
--profile custom-labels-access
```
------
#### [ Python ]
Use o código a seguir para criar um conjunto de dados. Forneça as seguintes opções de linha de comando:
+ `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).
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
import argparse
import logging
import time
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def create_empty_dataset(rek_client, project_arn, dataset_type):
"""
Creates an empty 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).
"""
try:
#Create the dataset.
logger.info("Creating empty %s dataset for project %s",
dataset_type, project_arn)
dataset_type=dataset_type.upper()
response = rek_client.create_dataset(
ProjectArn=project_arn, DatasetType=dataset_type
)
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 empty dataset."
)
parser.add_argument(
"dataset_type", help="The type of the empty dataset that you want to create (train or test)."
)
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 empty {args.dataset_type} dataset for project {args.project_arn}")
# Create the empty dataset.
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
dataset_arn=create_empty_dataset(rekognition_client,
args.project_arn,
args.dataset_type.lower())
print(f"Finished creating empty dataset: {dataset_arn}")
except ClientError as err:
logger.exception("Problem creating empty dataset: %s", err)
print(f"Problem creating empty dataset: {err}")
except Exception as err:
logger.exception("Problem creating empty dataset: %s", err)
print(f"Problem creating empty dataset: {err}")
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
Use o código a seguir para criar um conjunto de dados. Forneça as seguintes opções de linha de comando:
+ `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).
```
/*
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.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.RekognitionException;
import java.net.URI;
import java.util.logging.Level;
import java.util.logging.Logger;
public class CreateEmptyDataset {
public static final Logger logger = Logger.getLogger(CreateEmptyDataset.class.getName());
public static String createMyEmptyDataset(RekognitionClient rekClient, String projectArn, String datasetType)
throws Exception, RekognitionException {
try {
logger.log(Level.INFO, "Creating empty {0} dataset for project : {1}",
new Object[] { datasetType.toString(), projectArn });
DatasetType requestDatasetType = null;
switch (datasetType) {
case "train":
requestDatasetType = DatasetType.TRAIN;
break;
case "test":
requestDatasetType = DatasetType.TEST;
break;
default:
logger.log(Level.SEVERE, "Unrecognized dataset type: {0}", datasetType);
throw new Exception("Unrecognized dataset type: " + datasetType);
}
CreateDatasetRequest createDatasetRequest = CreateDatasetRequest.builder().projectArn(projectArn)
.datasetType(requestDatasetType).build();
CreateDatasetResponse response = rekClient.createDataset(createDatasetRequest);
boolean created = false;
//Wait until updates finishes
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 datasetArn = null;
String projectArn = 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 empty dataset that you want to create (train or test).\n\n";
if (args.length != 2) {
System.out.println(USAGE);
System.exit(1);
}
projectArn = args[0];
datasetType = args[1];
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 = createMyEmptyDataset(rekClient, projectArn, datasetType);
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. Adicione imagens ao conjunto de dados. Para obter mais informações, consulte [Como adicionar mais imagens (SDK)](md-add-images.md#md-add-images-sdk).
# Como adicionar mais imagens a um conjunto de dados
É possível adicionar mais imagens aos seus conjuntos de dados usando o console do Amazon Rekognition Custom Labels ou chamando a API `UpdateDatasetEntries`.
**Topics**
+ [Como adicionar mais imagens (console)](#md-add-images-console)
+ [Como adicionar mais imagens (SDK)](#md-add-images-sdk)
## Como adicionar mais imagens (console)
Ao usar o console do Amazon Rekognition Custom Labels, as imagens são carregadas do seu computador local. As imagens são adicionadas ao local do bucket do Amazon S3 (console ou externo) onde as imagens usadas para criar o conjunto de dados são armazenadas.
**Para adicionar mais imagens ao seu conjunto de dados (console)**
1. Abra o console do Amazon Rekognition em. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. No painel esquerdo, escolha **Usar rótulos personalizados**. A página inicial do Amazon Rekognition Custom Labels é exibida.
1. No painel de navegação esquerdo, selecione **Projetos**. A visualização Projetos é exibida.
1. Escolha o projeto que você deseja usar.
1. No painel de navegação esquerdo, abaixo do nome do projeto, escolha **Conjunto de dados**.
1. Escolha **Ações** e selecione o conjunto de dados ao qual você deseja adicionar imagens.
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. É possível fazer upload de até 30 imagens por vez.
1. Escolha **Fazer upload de imagens**.
1. Escolha **Salvar alterações**.
1. Rotule as imagens. Para obter mais informações, consulte [Rotulagem de imagens](md-labeling-images.md).
## Como adicionar mais imagens (SDK)
`UpdateDatasetEntries` atualiza ou adiciona linhas JSON a um arquivo de manifesto. Passe as linhas JSON como um objeto de dados codificado em byte64 no campo `GroundTruth`. Se você estiver usando um AWS SDK para fazer chamadas`UpdateDatasetEntries`, o SDK codifica os dados para você. Cada linha JSON contém informações para uma única imagem, como rótulos atribuídos ou informações da caixa delimitadora. Por exemplo:
```
{"source-ref":"s3://bucket/image","BB":{"annotations":[{"left":1849,"top":1039,"width":422,"height":283,"class_id":0},{"left":1849,"top":1340,"width":443,"height":415,"class_id":1},{"left":2637,"top":1380,"width":676,"height":338,"class_id":2},{"left":2634,"top":1051,"width":673,"height":338,"class_id":3}],"image_size":[{"width":4000,"height":2667,"depth":3}]},"BB-metadata":{"job-name":"labeling-job/BB","class-map":{"0":"comparator","1":"pot_resistor","2":"ir_phototransistor","3":"ir_led"},"human-annotated":"yes","objects":[{"confidence":1},{"confidence":1},{"confidence":1},{"confidence":1}],"creation-date":"2021-06-22T10:11:18.006Z","type":"groundtruth/object-detection"}}
```
Para obter mais informações, consulte [Criar um arquivo de manifesto](md-create-manifest-file.md).
Use o campo `source-ref` como uma chave para identificar as imagens que você deseja atualizar. Se o conjunto de dados não contiver um valor de campo `source-ref` correspondente, a linha JSON será adicionada como uma nova imagem.
**Para adicionar mais imagens a um conjunto de dados (SDK)**
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. Use os exemplos a seguir para adicionar linhas JSON a um conjunto de dados.
------
#### [ CLI ]
Substitua o valor de `GroundTruth` pelas linhas JSON que você deseja usar. É necessário escapar de qualquer caractere especial dentro da linha JSON.
```
aws rekognition update-dataset-entries\
--dataset-arn dataset_arn \
--changes '{"GroundTruth" : "{\"source-ref\":\"s3://your_bucket/your_image\",\"BB\":{\"annotations\":[{\"left\":1776,\"top\":1017,\"width\":458,\"height\":317,\"class_id\":0},{\"left\":1797,\"top\":1334,\"width\":418,\"height\":415,\"class_id\":1},{\"left\":2597,\"top\":1361,\"width\":655,\"height\":329,\"class_id\":2},{\"left\":2581,\"top\":1020,\"width\":689,\"height\":338,\"class_id\":3}],\"image_size\":[{\"width\":4000,\"height\":2667,\"depth\":3}]},\"BB-metadata\":{\"job-name\":\"labeling-job/BB\",\"class-map\":{\"0\":\"comparator\",\"1\":\"pot_resistor\",\"2\":\"ir_phototransistor\",\"3\":\"ir_led\"},\"human-annotated\":\"yes\",\"objects\":[{\"confidence\":1},{\"confidence\":1},{\"confidence\":1},{\"confidence\":1}],\"creation-date\":\"2021-06-22T10:10:48.492Z\",\"type\":\"groundtruth/object-detection\"}}" }' \
--cli-binary-format raw-in-base64-out \
--profile custom-labels-access
```
------
#### [ Python ]
Use o seguinte código: Forneça os seguintes parâmetros de linha de comando:
+ dataset\$1arn``: o ARN do conjunto de dados que você deseja atualizar.
+ updates\$1file ``: o arquivo que contém as atualizações da linha JSON.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Purpose
Shows how to add entries to an Amazon Rekognition Custom Labels dataset.
"""
import argparse
import logging
import time
import json
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def update_dataset_entries(rek_client, dataset_arn, updates_file):
"""
Adds dataset entries to an Amazon Rekognition Custom Labels dataset.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param dataset_arn: The ARN of the dataset that yuo want to update.
:param updates_file: The manifest file of JSON Lines that contains the updates.
"""
try:
status=""
status_message=""
# Update dataset entries.
logger.info("Updating dataset %s", dataset_arn)
with open(updates_file) as f:
manifest_file = f.read()
changes=json.loads('{ "GroundTruth" : ' +
json.dumps(manifest_file) +
'}')
rek_client.update_dataset_entries(
Changes=changes, DatasetArn=dataset_arn
)
finished=False
while finished is False:
dataset=rek_client.describe_dataset(DatasetArn=dataset_arn)
status=dataset['DatasetDescription']['Status']
status_message=dataset['DatasetDescription']['StatusMessage']
if status == "UPDATE_IN_PROGRESS":
logger.info("Updating dataset: %s ", dataset_arn)
time.sleep(5)
continue
if status == "UPDATE_COMPLETE":
logger.info("Dataset updated: %s : %s : %s",
status, status_message, dataset_arn)
finished=True
continue
if status == "UPDATE_FAILED":
error_message = f"Dataset update failed: {status} : {status_message} : {dataset_arn}"
logger.exception(error_message)
raise Exception (error_message)
error_message = f"Failed. Unexpected state for dataset update: {status} : {status_message} : {dataset_arn}"
logger.exception(error_message)
raise Exception(error_message)
logger.info("Added entries to dataset")
return status, status_message
except ClientError as err:
logger.exception("Couldn't update 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(
"dataset_arn", help="The ARN of the dataset that you want to update."
)
parser.add_argument(
"updates_file", help="The manifest file of JSON Lines that contains the updates."
)
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"Updating dataset {args.dataset_arn} with entries from {args.updates_file}.")
# Update the dataset.
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
status, status_message=update_dataset_entries(rekognition_client,
args.dataset_arn,
args.updates_file)
print(f"Finished updates dataset: {status} : {status_message}")
except ClientError as err:
logger.exception("Problem updating dataset: %s", err)
print(f"Problem updating dataset: {err}")
except Exception as err:
logger.exception("Problem updating dataset: %s", err)
print(f"Problem updating dataset: {err}")
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
+ dataset\$1arn``: o ARN do conjunto de dados que você deseja atualizar.
+ update\$1file ``: o arquivo que contém as atualizações da linha JSON.
```
/*
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.core.SdkBytes;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.DatasetChanges;
import software.amazon.awssdk.services.rekognition.model.DatasetDescription;
import software.amazon.awssdk.services.rekognition.model.DatasetStatus;
import software.amazon.awssdk.services.rekognition.model.DescribeDatasetRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeDatasetResponse;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import software.amazon.awssdk.services.rekognition.model.UpdateDatasetEntriesRequest;
import software.amazon.awssdk.services.rekognition.model.UpdateDatasetEntriesResponse;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.logging.Level;
import java.util.logging.Logger;
public class UpdateDatasetEntries {
public static final Logger logger = Logger.getLogger(UpdateDatasetEntries.class.getName());
public static String updateMyDataset(RekognitionClient rekClient, String datasetArn,
String updateFile
) throws Exception, RekognitionException {
try {
logger.log(Level.INFO, "Updating dataset {0}",
new Object[] { datasetArn});
InputStream sourceStream = new FileInputStream(updateFile);
SdkBytes sourceBytes = SdkBytes.fromInputStream(sourceStream);
DatasetChanges datasetChanges = DatasetChanges.builder()
.groundTruth(sourceBytes).build();
UpdateDatasetEntriesRequest updateDatasetEntriesRequest = UpdateDatasetEntriesRequest.builder()
.changes(datasetChanges)
.datasetArn(datasetArn)
.build();
UpdateDatasetEntriesResponse response = rekClient.updateDatasetEntries(updateDatasetEntriesRequest);
boolean updated = false;
//Wait until update completes
do {
DescribeDatasetRequest describeDatasetRequest = DescribeDatasetRequest.builder()
.datasetArn(datasetArn).build();
DescribeDatasetResponse describeDatasetResponse = rekClient.describeDataset(describeDatasetRequest);
DatasetDescription datasetDescription = describeDatasetResponse.datasetDescription();
DatasetStatus status = datasetDescription.status();
logger.log(Level.INFO, " dataset ARN: {0} ", datasetArn);
switch (status) {
case UPDATE_COMPLETE:
logger.log(Level.INFO, "Dataset updated");
updated = true;
break;
case UPDATE_IN_PROGRESS:
Thread.sleep(5000);
break;
case UPDATE_FAILED:
String error = "Dataset update failed: " + datasetDescription.statusAsString() + " "
+ datasetDescription.statusMessage() + " " + datasetArn;
logger.log(Level.SEVERE, error);
throw new Exception(error);
default:
String unexpectedError = "Unexpected update state: " + datasetDescription.statusAsString() + " "
+ datasetDescription.statusMessage() + " " + datasetArn;
logger.log(Level.SEVERE, unexpectedError);
throw new Exception(unexpectedError);
}
} while (updated == false);
return datasetArn;
} catch (RekognitionException e) {
logger.log(Level.SEVERE, "Could not update dataset: {0}", e.getMessage());
throw e;
}
}
public static void main(String args[]) {
String updatesFile = null;
String datasetArn = null;
final String USAGE = "\n" + "Usage: " + " \n\n" + "Where:\n"
+ " dataset_arn - the ARN of the dataset that you want to update.\n\n"
+ " update_file - The file that includes in JSON Line updates.\n\n";
if (args.length != 2) {
System.out.println(USAGE);
System.exit(1);
}
datasetArn = args[0];
updatesFile = args[1];
try {
// Get the Rekognition client.
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// Update the dataset
datasetArn = updateMyDataset(rekClient, datasetArn, updatesFile);
System.out.println(String.format("Dataset updated: %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);
}
}
}
```
------
# Como criar um conjunto de dados usando um conjunto de dados existente (SDK)
O procedimento a seguir mostra como criar um conjunto de dados a partir de um conjunto de dados existente usando a [CreateDataset](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateDataset)operação.
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. Use o código de exemplo a seguir para criar um conjunto de dados ao copiar outro conjunto de dados.
------
#### [ AWS CLI ]
Use o código a seguir para criar o conjunto de dados. Substitua o seguinte:
+ `project_arn`: o ARN do projeto ao qual você deseja adicionar o conjunto de dados.
+ `dataset_type`: com o tipo de conjunto de dados (`TRAIN` ou`TEST`) que você deseja criar no projeto.
+ `dataset_arn`: com o ARN do conjunto de dados que você deseja copiar.
```
aws rekognition create-dataset --project-arn project_arn \
--dataset-type dataset_type \
--dataset-source '{ "DatasetArn" : "dataset_arn" }' \
--profile custom-labels-access
```
------
#### [ Python ]
O exemplo a seguir cria um conjunto de dados usando um conjunto de dados existente e exibe seu ARN.
Para executar o programa, forneça os seguintes argumentos de linha de comando:
+ `project_arn`: o ARN do projeto que você deseja usar.
+ `dataset_type`: o tipo do conjunto de dados do projeto que você deseja criar (`train` ou `test`).
+ `dataset_arn`: o ARN do conjunto de dados do qual você deseja criar o conjunto de dados.
```
# 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_from_existing_dataset(rek_client, project_arn, dataset_type, dataset_arn):
"""
Creates an Amazon Rekognition Custom Labels dataset using an existing 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 dataset_arn: The ARN of the existing dataset that you want to use.
"""
try:
# Create the dataset
dataset_type=dataset_type.upper()
logger.info(
"Creating %s dataset for project %s from dataset %s.",
dataset_type,project_arn, dataset_arn)
dataset_source = json.loads(
'{ "DatasetArn": "' + dataset_arn + '"}'
)
response = rek_client.create_dataset(
ProjectArn=project_arn, DatasetType=dataset_type, DatasetSource=dataset_source
)
dataset_arn = response['DatasetArn']
logger.info("New 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(
"dataset_arn", help="The ARN of the dataset that you want to copy from."
)
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_from_existing_dataset(rekognition_client,
args.project_arn,
args.dataset_type,
args.dataset_arn)
print(f"Finished creating dataset: {dataset_arn}")
except ClientError as err:
logger.exception("Problem creating dataset: %s", err)
print(f"Problem creating dataset: {err}")
except Exception as err:
logger.exception("Problem creating dataset: %s", err)
print(f"Problem creating dataset: {err}")
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
O exemplo a seguir cria um conjunto de dados usando um conjunto de dados existente e exibe seu ARN.
Para executar o programa, forneça os seguintes argumentos de linha de comando:
+ `project_arn`: o ARN do projeto que você deseja usar.
+ `dataset_type`: o tipo do conjunto de dados do projeto que você deseja criar (`train` ou `test`).
+ `dataset_arn`: o ARN do conjunto de dados do qual você deseja criar o conjunto de dados.
```
/*
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.RekognitionException;
import java.util.logging.Level;
import java.util.logging.Logger;
public class CreateDatasetExisting {
public static final Logger logger = Logger.getLogger(CreateDatasetExisting.class.getName());
public static String createMyDataset(RekognitionClient rekClient, String projectArn, String datasetType,
String existingDatasetArn) throws Exception, RekognitionException {
try {
logger.log(Level.INFO, "Creating {0} dataset for project : {1} from dataset {2} ",
new Object[] { datasetType.toString(), projectArn, existingDatasetArn });
DatasetType requestDatasetType = null;
switch (datasetType) {
case "train":
requestDatasetType = DatasetType.TRAIN;
break;
case "test":
requestDatasetType = DatasetType.TEST;
break;
default:
logger.log(Level.SEVERE, "Unrecognized dataset type: {0}", datasetType);
throw new Exception("Unrecognized dataset type: " + datasetType);
}
DatasetSource datasetSource = DatasetSource.builder().datasetArn(existingDatasetArn).build();
CreateDatasetRequest createDatasetRequest = CreateDatasetRequest.builder().projectArn(projectArn)
.datasetType(requestDatasetType).datasetSource(datasetSource).build();
CreateDatasetResponse response = rekClient.createDataset(createDatasetRequest);
boolean created = false;
//Wait until create finishes
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 datasetArn = null;
String projectArn = null;
String datasetSourceArn = 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"
+ " dataset_arn - the ARN of the dataset that you want to copy from.\n\n";
if (args.length != 3) {
System.out.println(USAGE);
System.exit(1);
}
projectArn = args[0];
datasetType = args[1];
datasetSourceArn = args[2];
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, datasetSourceArn);
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);
}
}
}
```
------
# Como descrever um conjunto de dados (SDK)
É possível usar a API `DescribeDataset` para obter informações sobre um conjunto de dados.
**Para descrever um conjunto de dados (SDK)**
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. Use o código de exemplo a seguir para descrever um conjunto de dados.
------
#### [ AWS CLI ]
Altere o valor de `dataset-arn` para o ARN do conjunto de dados que você deseja escrever.
```
aws rekognition describe-dataset --dataset-arn dataset_arn \
--profile custom-labels-access
```
------
#### [ Python ]
Use o seguinte código: Forneça os seguintes parâmetros de linha de comando:
+ dataset\$1arn: o ARN do conjunto de dados que você deseja descrever.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Purpose
Shows how to describe an Amazon Rekognition Custom Labels dataset.
"""
import argparse
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def describe_dataset(rek_client, dataset_arn):
"""
Describes an Amazon Rekognition Custom Labels dataset.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param dataset_arn: The ARN of the dataset that you want to describe.
"""
try:
# Describe the dataset
logger.info("Describing dataset %s", dataset_arn)
dataset = rek_client.describe_dataset(DatasetArn=dataset_arn)
description = dataset['DatasetDescription']
print(f"Created: {str(description['CreationTimestamp'])}")
print(f"Updated: {str(description['LastUpdatedTimestamp'])}")
print(f"Status: {description['Status']}")
print(f"Status message: {description['StatusMessage']}")
print(f"Status code: {description['StatusMessageCode']}")
print("Stats:")
print(
f"\tLabeled entries: {description['DatasetStats']['LabeledEntries']}")
print(
f"\tTotal entries: {description['DatasetStats']['TotalEntries']}")
print(f"\tTotal labels: {description['DatasetStats']['TotalLabels']}")
except ClientError as err:
logger.exception("Couldn't describe 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(
"dataset_arn", help="The ARN of the dataset that you want to describe."
)
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"Describing dataset {args.dataset_arn}")
# Describe the dataset.
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
describe_dataset(rekognition_client, args.dataset_arn)
print(f"Finished describing dataset: {args.dataset_arn}")
except ClientError as err:
error_message=f"Problem describing dataset: {err}"
logger.exception(error_message)
print(error_message)
except Exception as err:
error_message = f"Problem describing dataset: {err}"
logger.exception(error_message)
print(error_message)
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
+ dataset\$1arn: o ARN do conjunto de dados que você deseja descrever.
```
/*
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.DatasetDescription;
import software.amazon.awssdk.services.rekognition.model.DatasetStats;
import software.amazon.awssdk.services.rekognition.model.DescribeDatasetRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeDatasetResponse;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import java.util.logging.Level;
import java.util.logging.Logger;
public class DescribeDataset {
public static final Logger logger = Logger.getLogger(DescribeDataset.class.getName());
public static void describeMyDataset(RekognitionClient rekClient, String datasetArn) {
try {
DescribeDatasetRequest describeDatasetRequest = DescribeDatasetRequest.builder().datasetArn(datasetArn)
.build();
DescribeDatasetResponse describeDatasetResponse = rekClient.describeDataset(describeDatasetRequest);
DatasetDescription datasetDescription = describeDatasetResponse.datasetDescription();
DatasetStats datasetStats = datasetDescription.datasetStats();
System.out.println("ARN: " + datasetArn);
System.out.println("Created: " + datasetDescription.creationTimestamp().toString());
System.out.println("Updated: " + datasetDescription.lastUpdatedTimestamp().toString());
System.out.println("Status: " + datasetDescription.statusAsString());
System.out.println("Message: " + datasetDescription.statusMessage());
System.out.println("Total Labels: " + datasetStats.totalLabels().toString());
System.out.println("Total entries: " + datasetStats.totalEntries().toString());
System.out.println("Entries with labels: " + datasetStats.labeledEntries().toString());
System.out.println("Entries with at least 1 error: " + datasetStats.errorEntries().toString());
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
throw rekError;
}
}
public static void main(String[] args) {
final String USAGE = "\n" + "Usage: " + "\n\n" + "Where:\n"
+ " dataset_arn - The ARN of the dataset that you want to describe.\n\n";
if (args.length != 1) {
System.out.println(USAGE);
System.exit(1);
}
String datasetArn = args[0];
try {
// Get the Rekognition client.
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// Describe the dataset.
describeMyDataset(rekClient, datasetArn);
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
}
}
}
```
------
# Como listar entradas do conjunto de dados (SDK)
É possível usar a API `ListDatasetEntries` para listar as linhas JSON de cada imagem em um conjunto de dados. Para obter mais informações, consulte [Criar um arquivo de manifesto](md-create-manifest-file.md).
**Para listar entradas do conjunto de dados (SDK)**
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. Use o código de exemplo a seguir: liste as entradas em um conjunto de dados.
------
#### [ AWS CLI ]
Altere o valor de `dataset-arn` para o ARN do conjunto de dados que você deseja listar.
```
aws rekognition list-dataset-entries --dataset-arn dataset_arn \
--profile custom-labels-access
```
Para listar somente linhas JSON com erros, especifique `has-errors`.
```
aws rekognition list-dataset-entries --dataset-arn dataset_arn \
--has-errors \
--profile custom-labels-access
```
------
#### [ Python ]
Use o seguinte código: Forneça os seguintes parâmetros de linha de comando:
+ dataset\$1arn: o ARN do conjunto de dados que você deseja listar.
+ show\$1errors\$1only: especifique `true` se deseja ver somente erros. `false`, caso contrário.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Purpose
Shows how to list the entries in an Amazon Rekognition Custom Labels dataset.
"""
import argparse
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def list_dataset_entries(rek_client, dataset_arn, show_errors):
"""
Lists the entries in an Amazon Rekognition Custom Labels dataset.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param dataset_arn: The ARN of the dataet that you want to use.
"""
try:
# List the entries.
logger.info("Listing dataset entries for the dataset %s.", dataset_arn)
finished = False
count = 0
next_token = ""
show_errors_only = False
if show_errors.lower() == "true":
show_errors_only = True
while finished is False:
response = rek_client.list_dataset_entries(
DatasetArn=dataset_arn,
HasErrors=show_errors_only,
MaxResults=100,
NextToken=next_token)
count += len(response['DatasetEntries'])
for entry in response['DatasetEntries']:
print(entry)
if 'NextToken' not in response:
finished = True
logger.info("No more entries. Total:%s", count)
else:
next_token = next_token = response['NextToken']
logger.info("Getting more entries. Total so far :%s", count)
except ClientError as err:
logger.exception(
"Couldn't list 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(
"dataset_arn", help="The ARN of the dataset that you want to list."
)
parser.add_argument(
"show_errors_only", help="true if you want to see errors only. false otherwise."
)
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"Listing entries for dataset {args.dataset_arn}")
# List the dataset entries.
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
list_dataset_entries(rekognition_client,
args.dataset_arn,
args.show_errors_only)
print(f"Finished listing entries for dataset: {args.dataset_arn}")
except ClientError as err:
error_message = f"Problem listing dataset: {err}"
logger.exception(error_message)
print(error_message)
except Exception as err:
error_message = f"Problem listing dataset: {err}"
logger.exception(error_message)
print(error_message)
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
Use o seguinte código: Forneça os seguintes parâmetros de linha de comando:
+ dataset\$1arn: o ARN do conjunto de dados que você deseja listar.
+ show\$1errors\$1only: especifique `true` se deseja ver somente erros. `false`, caso contrário.
```
/*
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.ListDatasetEntriesRequest;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import software.amazon.awssdk.services.rekognition.paginators.ListDatasetEntriesIterable;
import java.net.URI;
import java.util.logging.Level;
import java.util.logging.Logger;
public class ListDatasetEntries {
public static final Logger logger = Logger.getLogger(ListDatasetEntries.class.getName());
public static void listMyDatasetEntries(RekognitionClient rekClient, String datasetArn, boolean showErrorsOnly)
throws Exception, RekognitionException {
try {
logger.log(Level.INFO, "Listing dataset {0}", new Object[] { datasetArn });
ListDatasetEntriesRequest listDatasetEntriesRequest = ListDatasetEntriesRequest.builder()
.hasErrors(showErrorsOnly).datasetArn(datasetArn).maxResults(1).build();
ListDatasetEntriesIterable datasetEntriesList = rekClient
.listDatasetEntriesPaginator(listDatasetEntriesRequest);
datasetEntriesList.stream().flatMap(r -> r.datasetEntries().stream())
.forEach(datasetEntry -> System.out.println(datasetEntry.toString()));
} catch (RekognitionException e) {
logger.log(Level.SEVERE, "Could not update dataset: {0}", e.getMessage());
throw e;
}
}
public static void main(String args[]) {
boolean showErrorsOnly = false;
String datasetArn = null;
final String USAGE = "\n" + "Usage: " + " \n\n" + "Where:\n"
+ " dataset_arn - the ARN of the dataset that you want to update.\n\n"
+ " show_errors_only - true to show only errors. false otherwise.\n\n";
if (args.length != 2) {
System.out.println(USAGE);
System.exit(1);
}
datasetArn = args[0];
if (args[1].toLowerCase().equals("true")) {
showErrorsOnly = true;
}
try {
// Get the Rekognition client.
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// list the dataset entries.
listMyDatasetEntries(rekClient, datasetArn, showErrorsOnly);
System.out.println(String.format("Finished listing entries for : %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);
}
}
}
```
------
# Como distribuir um conjunto de dados de treinamento (SDK)
O Amazon Rekognition Custom Labels exige um conjunto de dados de treinamento e um conjunto de dados de teste para treinar o seu modelo.
Se você estiver usando a API, poderá usá-la para distribuir 20% do conjunto de dados de treinamento em um conjunto de dados de teste vazio. [DistributeDatasetEntries](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DistributeDatasetEntries) Distribuir o conjunto de dados de treinamento pode ser útil se houver apenas um único arquivo de manifesto disponível. Use o arquivo de manifesto único para criar seu conjunto de dados de treinamento. Em seguida, crie um conjunto de dados de teste vazio e use `DistributeDatasetEntries` para preencher o conjunto de dados de teste.
**nota**
Se estiver usando o console do Amazon Rekognition Custom Labels e começar com um único projeto de conjunto de dados, o Amazon Rekognition Custom Labels divide (distribui) o conjunto de dados de treinamento, durante o treinamento, para criar um conjunto de dados de teste. 20% das entradas do conjunto de dados de treinamento são movidas para o conjunto de dados de teste.
**Para distribuir um conjunto de dados de treinamento (SDK)**
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 projeto. Para obter mais informações, consulte [Como criar um projeto do Amazon Rekognition Custom Labels (SDK)](mp-create-project.md#mp-create-project-sdk).
1. Crie seu conjunto de dados de treinamento. Para obter informações sobre conjuntos de dados, consulte [Como criar conjuntos de dados de treinamento e teste](creating-datasets.md).
1. Criar um conjunto de dados de teste vazio.
1. Use o código de exemplo a seguir para distribuir 20% das entradas do conjunto de dados de treinamento no conjunto de dados de teste. Você pode obter os Amazon Resource Names (ARN) para os conjuntos de dados de um projeto ligando para. [DescribeProjects](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DescribeProjects) Para obter um código de exemplo, consulte [Como descrever um projeto (SDK)](md-describing-project-sdk.md).
------
#### [ AWS CLI ]
Altere o valor de `training_dataset-arn` e `test_dataset_arn` com o ARNS dos conjuntos de dados que você deseja usar.
```
aws rekognition distribute-dataset-entries --datasets ['{"Arn": "training_dataset_arn"}, {"Arn": "test_dataset_arn"}'] \
--profile custom-labels-access
```
------
#### [ Python ]
Use o seguinte código: Forneça os seguintes parâmetros de linha de comando:
+ training\$1dataset\$1arn: o ARN do conjunto de dados de teste do qual as entradas são distribuídas.
+ test\$1dataset\$1arn: o ARN do conjunto de dados de teste para o qual as entradas são distribuídas.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
import argparse
import logging
import time
import json
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def check_dataset_status(rek_client, dataset_arn):
"""
Checks the current status of a dataset.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param dataset_arn: The dataset that you want to check.
:return: The dataset status and status message.
"""
finished = False
status = ""
status_message = ""
while finished is False:
dataset = rek_client.describe_dataset(DatasetArn=dataset_arn)
status = dataset['DatasetDescription']['Status']
status_message = dataset['DatasetDescription']['StatusMessage']
if status == "UPDATE_IN_PROGRESS":
logger.info("Distributing dataset: %s ", dataset_arn)
time.sleep(5)
continue
if status == "UPDATE_COMPLETE":
logger.info(
"Dataset distribution complete: %s : %s : %s",
status, status_message, dataset_arn)
finished = True
continue
if status == "UPDATE_FAILED":
logger.exception(
"Dataset distribution failed: %s : %s : %s",
status, status_message, dataset_arn)
finished = True
break
logger.exception(
"Failed. Unexpected state for dataset distribution: %s : %s : %s",
status, status_message, dataset_arn)
finished = True
status_message = "An unexpected error occurred while distributing the dataset"
break
return status, status_message
def distribute_dataset_entries(rek_client, training_dataset_arn, test_dataset_arn):
"""
Distributes 20% of the supplied training dataset into the supplied test dataset.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param training_dataset_arn: The ARN of the training dataset that you distribute entries from.
:param test_dataset_arn: The ARN of the test dataset that you distribute entries to.
"""
try:
# List dataset labels.
logger.info("Distributing training dataset entries (%s) into test dataset (%s).",
training_dataset_arn,test_dataset_arn)
datasets = json.loads(
'[{"Arn" : "' + str(training_dataset_arn) + '"},{"Arn" : "' + str(test_dataset_arn) + '"}]')
rek_client.distribute_dataset_entries(
Datasets=datasets
)
training_dataset_status, training_dataset_status_message = check_dataset_status(
rek_client, training_dataset_arn)
test_dataset_status, test_dataset_status_message = check_dataset_status(
rek_client, test_dataset_arn)
if training_dataset_status == 'UPDATE_COMPLETE' and test_dataset_status == "UPDATE_COMPLETE":
print("Distribution complete")
else:
print("Distribution failed:")
print(
f"\ttraining dataset: {training_dataset_status} : {training_dataset_status_message}")
print(
f"\ttest dataset: {test_dataset_status} : {test_dataset_status_message}")
except ClientError as err:
logger.exception(
"Couldn't distribute 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(
"training_dataset_arn", help="The ARN of the training dataset that you want to distribute from."
)
parser.add_argument(
"test_dataset_arn", help="The ARN of the test dataset that you want to distribute to."
)
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"Distributing training dataset entries ({args.training_dataset_arn}) "\
f"into test dataset ({args.test_dataset_arn}).")
# Distribute the datasets.
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
distribute_dataset_entries(rekognition_client,
args.training_dataset_arn,
args.test_dataset_arn)
print("Finished distributing datasets.")
except ClientError as err:
logger.exception("Problem distributing datasets: %s", err)
print(f"Problem listing dataset labels: {err}")
except Exception as err:
logger.exception("Problem distributing datasets: %s", err)
print(f"Problem distributing datasets: {err}")
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
Use o seguinte código: Forneça os seguintes parâmetros de linha de comando:
+ training\$1dataset\$1arn: o ARN do conjunto de dados de teste do qual as entradas são distribuídas.
+ test\$1dataset\$1arn: o ARN do conjunto de dados de teste para o qual as entradas são distribuídas.
```
/*
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.DatasetDescription;
import software.amazon.awssdk.services.rekognition.model.DatasetStatus;
import software.amazon.awssdk.services.rekognition.model.DescribeDatasetRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeDatasetResponse;
import software.amazon.awssdk.services.rekognition.model.DistributeDataset;
import software.amazon.awssdk.services.rekognition.model.DistributeDatasetEntriesRequest;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import java.util.ArrayList;
import java.util.logging.Level;
import java.util.logging.Logger;
public class DistributeDatasetEntries {
public static final Logger logger = Logger.getLogger(DistributeDatasetEntries.class.getName());
public static DatasetStatus checkDatasetStatus(RekognitionClient rekClient, String datasetArn)
throws Exception, RekognitionException {
boolean distributed = false;
DatasetStatus status = null;
// Wait until distribution completes
do {
DescribeDatasetRequest describeDatasetRequest = DescribeDatasetRequest.builder().datasetArn(datasetArn)
.build();
DescribeDatasetResponse describeDatasetResponse = rekClient.describeDataset(describeDatasetRequest);
DatasetDescription datasetDescription = describeDatasetResponse.datasetDescription();
status = datasetDescription.status();
logger.log(Level.INFO, " dataset ARN: {0} ", datasetArn);
switch (status) {
case UPDATE_COMPLETE:
logger.log(Level.INFO, "Dataset updated");
distributed = true;
break;
case UPDATE_IN_PROGRESS:
Thread.sleep(5000);
break;
case UPDATE_FAILED:
String error = "Dataset distribution failed: " + datasetDescription.statusAsString() + " "
+ datasetDescription.statusMessage() + " " + datasetArn;
logger.log(Level.SEVERE, error);
break;
default:
String unexpectedError = "Unexpected distribution state: " + datasetDescription.statusAsString() + " "
+ datasetDescription.statusMessage() + " " + datasetArn;
logger.log(Level.SEVERE, unexpectedError);
}
} while (distributed == false);
return status;
}
public static void distributeMyDatasetEntries(RekognitionClient rekClient, String trainingDatasetArn,
String testDatasetArn) throws Exception, RekognitionException {
try {
logger.log(Level.INFO, "Distributing {0} dataset to {1} ",
new Object[] { trainingDatasetArn, testDatasetArn });
DistributeDataset distributeTrainingDataset = DistributeDataset.builder().arn(trainingDatasetArn).build();
DistributeDataset distributeTestDataset = DistributeDataset.builder().arn(testDatasetArn).build();
ArrayList datasets = new ArrayList();
datasets.add(distributeTrainingDataset);
datasets.add(distributeTestDataset);
DistributeDatasetEntriesRequest distributeDatasetEntriesRequest = DistributeDatasetEntriesRequest.builder()
.datasets(datasets).build();
rekClient.distributeDatasetEntries(distributeDatasetEntriesRequest);
DatasetStatus trainingStatus = checkDatasetStatus(rekClient, trainingDatasetArn);
DatasetStatus testStatus = checkDatasetStatus(rekClient, testDatasetArn);
if (trainingStatus == DatasetStatus.UPDATE_COMPLETE && testStatus == DatasetStatus.UPDATE_COMPLETE) {
logger.log(Level.INFO, "Successfully distributed dataset: {0}", trainingDatasetArn);
} else {
throw new Exception("Failed to distribute dataset: " + trainingDatasetArn);
}
} catch (RekognitionException e) {
logger.log(Level.SEVERE, "Could not distribute dataset: {0}", e.getMessage());
throw e;
}
}
public static void main(String[] args) {
String trainingDatasetArn = null;
String testDatasetArn = null;
final String USAGE = "\n" + "Usage: " + " \n\n" + "Where:\n"
+ " training_dataset_arn - the ARN of the dataset that you want to distribute from.\n\n"
+ " test_dataset_arn - the ARN of the dataset that you want to distribute to.\n\n";
if (args.length != 2) {
System.out.println(USAGE);
System.exit(1);
}
trainingDatasetArn = args[0];
testDatasetArn = args[1];
try {
// Get the Rekognition client.
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// Distribute the dataset
distributeMyDatasetEntries(rekClient, trainingDatasetArn, testDatasetArn);
System.out.println("Datasets distributed.");
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);
}
}
}
```
------
# Como excluir um conjunto de dados
É possível excluir os conjuntos de dados de treinamento e teste de um projeto.
**Topics**
+ [Como excluir um conjunto de dados (console)](#md-delete-dataset-console)
+ [Como excluir um conjunto de dados do Amazon Rekognition Custom Labels (SDK)](#md-delete-dataset-sdk)
## Como excluir um conjunto de dados (console)
Use o procedimento a seguir para excluir um conjunto de dados. Depois, se o projeto tiver um conjunto de dados restante (treinamento ou teste), a página de detalhes do projeto será exibida. Se o projeto não tiver conjuntos de dados restantes, a página **Criar conjunto de dados** será exibida.
Se excluir o conjunto de dados de treinamento, deverá criar um novo conjunto de dados de treinamento para o projeto antes de treinar um modelo. Para obter mais informações, consulte [Como criar conjuntos de dados de treinamento e teste com imagens](md-create-dataset.md).
Se excluir o conjunto de dados de teste, poderá treinar um modelo sem criar um novo conjunto de dados de teste. Durante o treinamento, o conjunto de dados de treinamento é dividido para criar um novo conjunto de dados de teste para o projeto. A divisão do conjunto de dados de treinamento reduz o número de imagens disponíveis para treinamento. Para manter a qualidade, recomendamos criar um novo conjunto de dados de teste antes de treinar um modelo. Para obter mais informações, consulte [Como adicionar um conjunto de dados a um projeto](md-add-dataset.md).
**Para excluir um conjunto de dados**
1. Abra o console do Amazon Rekognition em. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. No painel esquerdo, escolha **Usar rótulos personalizados**. A página inicial do Amazon Rekognition Custom Labels é exibida.
1. No painel de navegação esquerdo, selecione **Projetos**. A visualização Projetos é exibida.
1. Selecione o tópico que contém o conjunto de dados que você deseja excluir.
1. No painel de navegação esquerdo, abaixo do nome do projeto, escolha **Conjunto de dados**
1. Escolha **Ações**.
1. Para excluir o conjunto de dados de treinamento, escolha **Excluir conjunto de dados de treinamento**.
1. Para excluir o conjunto de dados de teste, escolha **Excluir conjunto de dados**.
1. Na caixa de diálogo **Excluir conjunto de dados de *treinamento ou teste***, insira **excluir** para confirmar que você deseja excluir o conjunto de dados.
1. Escolha **Excluir conjunto de dados de *treinamento ou teste*** para excluir o conjunto de dados.
## Como excluir um conjunto de dados do Amazon Rekognition Custom Labels (SDK)
Você exclui um conjunto de dados Amazon Rekognition Custom Labels [DeleteDataset](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DeleteDataset)chamando e fornecendo o Amazon Resource Name (ARN) do conjunto de dados que você deseja excluir. Para obter os conjuntos ARNs de dados de treinamento e teste em um projeto, ligue [DescribeProjects](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DescribeProjects). A resposta inclui uma matriz de [ProjectDescription](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ProjectDescription)objetos. O conjunto de dados ARNs (`DatasetArn`) e os tipos de conjunto de dados (`DatasetType`) estão na `Datasets` lista.
Se excluir o conjunto de dados de treinamento, precisará criar um novo conjunto de dados de treinamento para o projeto antes de treinar um modelo. Se excluir o conjunto de dados de teste, precisará criar um novo conjunto de dados de teste antes de treinar o modelo. Para obter mais informações, consulte [Como adicionar um conjunto de dados a um projeto (SDK)](md-add-dataset.md#md-add-dataset-sdk).
**Para excluir um conjunto de dados (SDK)**
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. Use o código a seguir para excluir um conjunto de dados.
------
#### [ AWS CLI ]
Altere o valor de `dataset-arn` para o ARN dos conjuntos de dados que você deseja excluir.
```
aws rekognition delete-dataset --dataset-arn dataset-arn \
--profile custom-labels-access
```
------
#### [ Python ]
Use o seguinte código: Forneça os seguintes parâmetros de linha de comando:
+ dataset\$1arn: o ARN do conjunto de dados que você deseja excluir.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Purpose
Shows how to delete an Amazon Rekognition Custom Labels dataset.
"""
import argparse
import logging
import time
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def delete_dataset(rek_client, dataset_arn):
"""
Deletes an Amazon Rekognition Custom Labels dataset.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param dataset_arn: The ARN of the dataset that you want to delete.
"""
try:
# Delete the dataset,
logger.info("Deleting dataset: %s", dataset_arn)
rek_client.delete_dataset(DatasetArn=dataset_arn)
deleted = False
logger.info("waiting for dataset deletion %s", dataset_arn)
# Dataset might not be deleted yet, so wait.
while deleted is False:
try:
rek_client.describe_dataset(DatasetArn=dataset_arn)
time.sleep(5)
except ClientError as err:
if err.response['Error']['Code'] == 'ResourceNotFoundException':
logger.info("dataset deleted: %s", dataset_arn)
deleted = True
else:
raise
logger.info("dataset deleted: %s", dataset_arn)
return True
except ClientError as err:
logger.exception("Couldn't delete dataset - %s: %s",
dataset_arn, 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(
"dataset_arn", help="The ARN of the dataset that you want to delete."
)
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"Deleting dataset: {args.dataset_arn}")
# Delete the dataset.
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
delete_dataset(rekognition_client,
args.dataset_arn)
print(f"Finished deleting dataset: {args.dataset_arn}")
except ClientError as err:
error_message = f"Problem deleting dataset: {err}"
logger.exception(error_message)
print(error_message)
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
Use o seguinte código: Forneça os seguintes parâmetros de linha de comando:
+ dataset\$1arn: o ARN do conjunto de dados que você deseja excluir.
```
/*
Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
SPDX-License-Identifier: Apache-2.0
*/
package com.example.rekognition;
import java.util.logging.Level;
import java.util.logging.Logger;
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.DeleteDatasetRequest;
import software.amazon.awssdk.services.rekognition.model.DeleteDatasetResponse;
import software.amazon.awssdk.services.rekognition.model.DescribeDatasetRequest;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
public class DeleteDataset {
public static final Logger logger = Logger.getLogger(DeleteDataset.class.getName());
public static void deleteMyDataset(RekognitionClient rekClient, String datasetArn) throws InterruptedException {
try {
logger.log(Level.INFO, "Deleting dataset: {0}", datasetArn);
// Delete the dataset
DeleteDatasetRequest deleteDatasetRequest = DeleteDatasetRequest.builder().datasetArn(datasetArn).build();
DeleteDatasetResponse response = rekClient.deleteDataset(deleteDatasetRequest);
// Wait until deletion finishes
DescribeDatasetRequest describeDatasetRequest = DescribeDatasetRequest.builder().datasetArn(datasetArn)
.build();
Boolean deleted = false;
do {
try {
rekClient.describeDataset(describeDatasetRequest);
Thread.sleep(5000);
} catch (RekognitionException e) {
String errorCode = e.awsErrorDetails().errorCode();
if (errorCode.equals("ResourceNotFoundException")) {
logger.log(Level.INFO, "Dataset deleted: {0}", datasetArn);
deleted = true;
} else {
logger.log(Level.SEVERE, "Client error occurred: {0}", e.getMessage());
throw e;
}
}
} while (Boolean.FALSE.equals(deleted));
logger.log(Level.INFO, "Dataset deleted: {0} ", datasetArn);
} catch (
RekognitionException e) {
logger.log(Level.SEVERE, "Client error occurred: {0}", e.getMessage());
throw e;
}
}
public static void main(String args[]) {
final String USAGE = "\n" + "Usage: " + "\n\n" + "Where:\n"
+ " dataset_arn - The ARN of the dataset that you want to delete.\n\n";
if (args.length != 1) {
System.out.println(USAGE);
System.exit(1);
}
String datasetArn = args[0];
try {
// Get the Rekognition client.
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// Delete the dataset
deleteMyDataset(rekClient, datasetArn);
System.out.println(String.format("Dataset deleted: %s", datasetArn));
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
}
catch (InterruptedException intError) {
logger.log(Level.SEVERE, "Exception while sleeping: {0}", intError.getMessage());
System.exit(1);
}
}
}
```
------