Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Utilizar un archivo de manifiesto para importar imágenes
Puede crear un conjunto de datos con un archivo de manifiesto en formato Amazon SageMaker AI Ground Truth. Puedes usar el archivo de manifiesto de un trabajo de Amazon SageMaker AI Ground Truth. Si tus imágenes y etiquetas no tienen el formato de un archivo de manifiesto de SageMaker AI Ground Truth, puedes crear un archivo de manifiesto en formato SageMaker AI y usarlo para importar las imágenes etiquetadas.
La operación `CreateDataset` se actualiza para que pueda especificar etiquetas de forma opcional al crear un nuevo conjunto de datos. Las etiquetas son pares clave-valor que puede usar para categorizar y administrar sus recursos.
**Topics**
+ [Creación de un conjunto de datos con un archivo de manifiesto de SageMaker AI Ground Truth (consola)](#md-create-dataset-ground-truth-console)
+ [Creación de un conjunto de datos con un archivo de manifiesto (SDK) de SageMaker AI Ground Truth](#md-create-dataset-ground-truth-sdk)
+ [Crear una solicitud de conjunto de datos](#create-dataset-ground-truth-request)
+ [Etiquetar imágenes con un trabajo de Amazon SageMaker AI Ground Truth](md-create-dataset-ground-truth-job.md)
+ [Creación de un archivo de manifiesto](md-create-manifest-file.md)
+ [Importación de etiquetas de imagen en los archivos de manifiesto](md-create-manifest-file-classification.md)
+ [Localización de objetos en archivos de manifiesto](md-create-manifest-file-object-detection.md)
+ [Reglas de validación de archivos de manifiesto](md-create-manifest-file-validation-rules.md)
+ [Convertir otros formatos de conjunto de datos en un archivo de manifiesto](md-converting-to-sm-format.md)
## Creación de un conjunto de datos con un archivo de manifiesto de SageMaker AI Ground Truth (consola)
El siguiente procedimiento muestra cómo crear un conjunto de datos mediante un archivo de manifiesto en formato SageMaker AI Ground Truth.
1. Cree un archivo de manifiesto para el conjunto de datos de entrenamiento de la siguiente manera:
+ Cree un archivo de manifiesto con un SageMaker AI GroundTruth Job siguiendo las instrucciones de[Etiquetar imágenes con un trabajo de Amazon SageMaker AI Ground Truth](md-create-dataset-ground-truth-job.md).
+ Cree su propio archivo de manifiesto siguiendo las instrucciones de [Creación de un archivo de manifiesto](md-create-manifest-file.md).
Si quiere crear un conjunto de datos de prueba, repita el paso 1 para crear el conjunto de datos de prueba.
1. Abra la consola Amazon Rekognition en. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Elija **Usar etiquetas personalizadas**.
1. Elija **Comenzar**.
1. En el panel de navegación izquierdo, elija **Proyectos**.
1. En la página **Proyectos**, elija el proyecto al que desee añadir el conjunto de datos. Se abrirá la página de detalles del proyecto.
1. Elija **Crear conjunto de datos**. Se abrirá la página **Crear conjunto de datos**.
1. En **Configuración inicial**, seleccione **Empezar con un único conjunto de datos** o **Empezar con un conjunto de datos de entrenamiento**. Para crear un modelo de mayor calidad, le recomendamos empezar con conjuntos de datos de entrenamiento y de prueba independientes.
------
#### [ Single dataset ]
1. En la sección de **detalles del conjunto de datos de entrenamiento**, selecciona **Importar imágenes etiquetadas por SageMaker Ground Truth**.
1. En la **ubicación del archivo de manifiesto**, introduzca la ubicación del archivo de manifiesto que creó en el paso 1.
1. Elija **Crear conjunto de datos**. Se abrirá la página de los conjuntos de datos de su proyecto.
------
#### [ Separate training and test datasets ]
1. En la sección de **detalles del conjunto de datos de entrenamiento**, selecciona **Importar imágenes etiquetadas por SageMaker Ground Truth**.
1. En la **ubicación del archivo de manifiesto**, introduzca la ubicación del archivo de manifiesto del conjunto de datos de entrenamiento que creó en el paso 1.
1. En la sección **Detalles del conjunto de datos de prueba**, selecciona **Importar imágenes etiquetadas por SageMaker Ground Truth**.
**nota**
Los conjuntos de datos de entrenamiento y de prueba pueden tener diferentes fuentes de imágenes.
1. En la **ubicación del archivo de manifiesto**, introduzca la ubicación del archivo de manifiesto del conjunto de datos de prueba que creó en el paso 1.
1. Elija **Crear conjuntos de datos**. Se abrirá la página de los conjuntos de datos de su proyecto.
------
1. Si necesita agregar o cambiar etiquetas, consulte [Etiquetado de imágenes](md-labeling-images.md).
1. Siga los pasos que se indican en [Entrenamiento de un modelo (consola)](training-model.md#tm-console) para entrenar el modelo.
## Creación de un conjunto de datos con un archivo de manifiesto (SDK) de SageMaker AI Ground Truth
El siguiente procedimiento muestra cómo crear conjuntos de datos de entrenamiento o prueba a partir de un archivo de manifiesto mediante la [CreateDataset](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateDataset)API.
Puedes usar un archivo de manifiesto existente, como el resultado de un [trabajo de SageMaker AI Ground Truth](md-create-dataset-ground-truth-job.md), o crear tu propio [archivo de manifiesto](md-create-manifest-file.md).
1. Si aún no lo has hecho, instala y configura el AWS CLI y el AWS SDKs. Para obtener más información, consulte [Paso 4: Configure el AWS CLI and AWS SDK](su-awscli-sdk.md).
1. Cree un archivo de manifiesto para el conjunto de datos de entrenamiento de la siguiente manera:
+ Cree un archivo de manifiesto con un SageMaker AI GroundTruth Job siguiendo las instrucciones de[Etiquetar imágenes con un trabajo de Amazon SageMaker AI Ground Truth](md-create-dataset-ground-truth-job.md).
+ Cree su propio archivo de manifiesto siguiendo las instrucciones de [Creación de un archivo de manifiesto](md-create-manifest-file.md).
Si quiere crear un conjunto de datos de prueba, repita el paso 2 para crear el conjunto de datos de prueba.
1. Use el siguiente código de ejemplo para crear el conjunto de datos de entrenamiento y prueba.
------
#### [ AWS CLI ]
Cree un conjunto de datos con el siguiente código. Sustituya lo siguiente:
+ `project_arn`: el ARN del proyecto al que desea agregar el conjunto de datos de prueba.
+ `type`: el tipo de conjunto de datos que desea crear (ENTRENAMIENTO o PRUEBA).
+ `bucket`: el bucket que contiene el archivo de manifiesto del conjunto de datos.
+ `manifest_file`: el nombre de archivo y la ruta del archivo de manifiesto.
```
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 ]
Cree un conjunto de datos con los siguientes valores. Indique los siguientes parámetros de línea de comandos:
+ `project_arn`: el ARN del proyecto al que desea agregar el conjunto de datos de prueba.
+ `dataset_type`: el tipo de conjunto de datos que desea crear (`train` o `test`).
+ `bucket`: el bucket que contiene el archivo de manifiesto del conjunto de datos.
+ `manifest_file`: el nombre de archivo y la ruta del archivo de manifiesto.
```
#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 ]
Cree un conjunto de datos con los siguientes valores. Indique los siguientes parámetros de línea de comandos:
+ `project_arn`: el ARN del proyecto al que desea agregar el conjunto de datos de prueba.
+ `dataset_type`: el tipo de conjunto de datos que desea crear (`train` o `test`).
+ `bucket`: el bucket que contiene el archivo de manifiesto del conjunto de datos.
+ `manifest_file`: el nombre de archivo y la ruta del archivo de manifiesto.
```
/*
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. Si necesita agregar o cambiar etiquetas, consulte [Administración de etiquetas (SDK)](md-labels.md#md-labels-sdk).
1. Siga los pasos que se indican en [Entrenamiento de un modelo (SDK)](training-model.md#tm-sdk) para entrenar el modelo.
## Crear una solicitud de conjunto de datos
El formato de la solicitud de CreateDataset operación es el siguiente:
```
{
"DatasetSource": {
"DatasetArn": "string",
"GroundTruthManifest": {
"S3Object": {
"Bucket": "string",
"Name": "string",
"Version": "string"
}
}
},
"DatasetType": "string",
"ProjectArn": "string",
"Tags": {
"string": "string"
}
}
```