Crear un conjunto de datos con un archivo de manifiesto (SDK)

La CreateDatasetoperación se utiliza para crear los conjuntos de datos asociados a un proyecto de Amazon Lookout for Vision.

Si desea utilizar un único conjunto de datos para el entrenamiento y las pruebas, cree un único conjunto de datos con el valor DatasetType establecido en train. Durante el entrenamiento, el conjunto de datos se divide internamente para crear un conjunto de datos de entrenamiento y prueba. No tiene acceso a los conjuntos de datos de entrenamiento y de prueba divididos. Si quiere un conjunto de datos de prueba independiente, realice una segunda llamada a CreateDataset con el valor DatasetType establecido en test. Durante el entrenamiento, los conjuntos de datos de entrenamiento y prueba se utilizan para entrenar y probar el modelo.

Si lo desea, puede utilizar el DatasetSource parámetro para especificar la ubicación de un archivo de manifiesto en formato SageMaker Ground Truth que se utiliza para rellenar el conjunto de datos. En este caso, la llamada a CreateDataset es asíncrona. Para comprobar el estado actual, llame a DescribeDataset. Para obtener más información, consulte Visualización de sus conjuntos de datos. Si se produce un error de validación durante la importación, el valor de Status se establece en CREATE _ FAILED y el mensaje de estado (StatusMessage) se establece.

sugerencia

Si va a crear un conjunto de datos con el conjunto de datos de ejemplo de introducción, utilice el archivo de manifiesto (getting-started/dataset-files/manifests/train.manifest) en el que se crea el script. Paso 1: Crear el archivo de manifiesto y cargar las imágenes

Si va a crear un conjunto de datos con las imágenes de ejemplo de la placa de circuito, tiene dos opciones:

1. Cree el archivo de manifiesto mediante código. El cuaderno de Python de Amazon Lookout for Vision Lab muestra cómo crear el archivo de manifiesto para las imágenes de ejemplo de la placa de circuito. Como alternativa, utilice el código de ejemplo de conjuntos de datos del repositorio de ejemplos AWS de código.

2. Si ya ha utilizado la consola de Amazon Lookout for Vision para crear un conjunto de datos con las imágenes de ejemplo de la placa de circuito, reutilice los archivos de manifiesto que Amazon Lookout for Vision creó para usted. Las ubicaciones de los archivos de manifiesto de entrenamiento y prueba son s3://bucket/datasets/project name/train or test/manifests/output/output.manifest.

Si no especifica DatasetSource, se crea un conjunto de datos vacío. En este caso, la llamada a CreateDataset es sincrónica. Más adelante, puedes etiquetar las imágenes en el conjunto de datos llamando UpdateDatasetEntries. Para ver el código de ejemplo, consulte Añadir más imágenes (SDK).

Si quieres reemplazar un conjunto de datos, primero elimina el conjunto de datos existente por uno nuevo del mismo tipo de conjunto de datos DeleteDatasety, a continuación, crea uno nuevo del mismo tipo de conjunto de datos mediante una llamadaCreateDataset. Para obtener más información, consulte Eliminación de un conjuntos de datos.

Después de crear los conjuntos de datos, puede crear el modelo. Para obtener más información, consulte Entrenando a un modelo (SDK).

Puedes ver las imágenes etiquetadas (JSONlíneas) dentro de un conjunto de datos llamando ListDatasetEntries. Puede añadir imágenes etiquetadas llamando a UpdateDatasetEntries.

Para ver información sobre los conjuntos de datos de prueba y entrenamiento, consulte Visualización de sus conjuntos de datos.

Para crear un conjunto de datos (SDK)

1. Si aún no lo ha hecho, instale y configure el AWS CLI y el AWS SDKs. Para obtener más información, consulte Paso 4: Configura el AWS CLI y AWS SDKs.

2. Cree un conjunto de datos con el siguiente ejemplo.

   CLI

   Cambie los siguientes valores:

   • project-nameal nombre del proyecto al que desea asociar el conjunto de datos.

   • dataset-typeal tipo de conjunto de datos que desea crear (trainotest).

   • dataset-source a la ubicación del archivo de manifiesto de Amazon S3.

   • Bucket al nombre del bucket de Amazon S3 que contiene el archivo de manifiesto.

   • Keya la ruta y el nombre de archivo del archivo de manifiesto en el bucket de Amazon S3.

   aws lookoutvision create-dataset --project-name project\
     --dataset-type train or test\
     --dataset-source '{ "GroundTruthManifest": { "S3Object": { "Bucket": "bucket", "Key": "manifest file" } } }' \
     --profile lookoutvision-access
   

   Python

   Este código se ha tomado del GitHub repositorio de SDK ejemplos de AWS documentación. Consulte el ejemplo completo aquí.

       @staticmethod
       def create_dataset(lookoutvision_client, project_name, manifest_file, dataset_type):
           """
           Creates a new Lookout for Vision dataset
   
           :param lookoutvision_client: A Lookout for Vision Boto3 client.
           :param project_name: The name of the project in which you want to
                                create a dataset.
           :param bucket: The bucket that contains the manifest file.
           :param manifest_file: The path and name of the manifest file.
           :param dataset_type: The type of the dataset (train or test).
           """
           try:
               bucket, key = manifest_file.replace("s3://", "").split("/", 1)
               logger.info("Creating %s dataset type...", dataset_type)
               dataset = {
                   "GroundTruthManifest": {"S3Object": {"Bucket": bucket, "Key": key}}
               }
               response = lookoutvision_client.create_dataset(
                   ProjectName=project_name,
                   DatasetType=dataset_type,
                   DatasetSource=dataset,
               )
               logger.info("Dataset Status: %s", response["DatasetMetadata"]["Status"])
               logger.info(
                   "Dataset Status Message: %s",
                   response["DatasetMetadata"]["StatusMessage"],
               )
               logger.info("Dataset Type: %s", response["DatasetMetadata"]["DatasetType"])
   
               # Wait until either created or failed.
               finished = False
               status = ""
               dataset_description = {}
               while finished is False:
                   dataset_description = lookoutvision_client.describe_dataset(
                       ProjectName=project_name, DatasetType=dataset_type
                   )
                   status = dataset_description["DatasetDescription"]["Status"]
   
                   if status == "CREATE_IN_PROGRESS":
                       logger.info("Dataset creation in progress...")
                       time.sleep(2)
                   elif status == "CREATE_COMPLETE":
                       logger.info("Dataset created.")
                       finished = True
                   else:
                       logger.info(
                           "Dataset creation failed: %s",
                           dataset_description["DatasetDescription"]["StatusMessage"],
                       )
                       finished = True
   
               if status != "CREATE_COMPLETE":
                   message = dataset_description["DatasetDescription"]["StatusMessage"]
                   logger.exception("Couldn't create dataset: %s", message)
                   raise Exception(f"Couldn't create dataset: {message}")
   
           except ClientError:
               logger.exception("Service error: Couldn't create dataset.")
               raise
   
   

   Java V2

   Este código se ha tomado del GitHub repositorio de SDK ejemplos de AWS documentación. Consulte el ejemplo completo aquí.

   /**
    * Creates an Amazon Lookout for Vision dataset from a manifest file.
    * Returns after Lookout for Vision creates the dataset.
    * 
    * @param lfvClient    An Amazon Lookout for Vision client.
    * @param projectName  The name of the project in which you want to create a
    *                     dataset.
    * @param datasetType  The type of dataset that you want to create (train or
    *                     test).
    * @param bucket       The S3 bucket that contains the manifest file.
    * @param manifestFile The name and location of the manifest file within the S3
    *                     bucket.
    * @return DatasetDescription The description of the created dataset.
    */
   public static DatasetDescription createDataset(LookoutVisionClient lfvClient,
                   String projectName,
                   String datasetType,
                   String bucket,
                   String manifestFile)
                   throws LookoutVisionException, InterruptedException {
   
           logger.log(Level.INFO, "Creating {0} dataset for project {1}",
                           new Object[] { projectName, datasetType });
   
           // Build the request. If no bucket supplied, setup for empty dataset creation.
           CreateDatasetRequest createDatasetRequest = null;
   
           if (bucket != null && manifestFile != null) {
   
                   InputS3Object s3Object = InputS3Object.builder()
                                   .bucket(bucket)
                                   .key(manifestFile)
                                   .build();
   
                   DatasetGroundTruthManifest groundTruthManifest = DatasetGroundTruthManifest.builder()
                                   .s3Object(s3Object)
                                   .build();
   
                   DatasetSource datasetSource = DatasetSource.builder()
                                   .groundTruthManifest(groundTruthManifest)
                                   .build();
   
                   createDatasetRequest = CreateDatasetRequest.builder()
                                   .projectName(projectName)
                                   .datasetType(datasetType)
                                   .datasetSource(datasetSource)
                                   .build();
           } else {
                   createDatasetRequest = CreateDatasetRequest.builder()
                                   .projectName(projectName)
                                   .datasetType(datasetType)
                                   .build();
           }
   
           lfvClient.createDataset(createDatasetRequest);
   
           DatasetDescription datasetDescription = null;
   
           boolean finished = false;
   
           // Wait until dataset is created, or failure occurs.
           while (!finished) {
   
                   datasetDescription = describeDataset(lfvClient, projectName, datasetType);
   
                   switch (datasetDescription.status()) {
                           case CREATE_COMPLETE:
                                   logger.log(Level.INFO, "{0}dataset created for project {1}",
                                                   new Object[] { datasetType, projectName });
                                   finished = true;
                                   break;
                           case CREATE_IN_PROGRESS:
                                   logger.log(Level.INFO, "{0} dataset creating for project {1}",
                                                   new Object[] { datasetType, projectName });
   
                                   TimeUnit.SECONDS.sleep(5);
   
                                   break;
   
                           case CREATE_FAILED:
                                   logger.log(Level.SEVERE,
                                                   "{0} dataset creation failed for project {1}. Error {2}",
                                                   new Object[] { datasetType, projectName,
                                                                   datasetDescription.statusAsString() });
                                   finished = true;
                                   break;
                           default:
                                   logger.log(Level.SEVERE, "{0} error when creating {1} dataset for project {2}",
                                                   new Object[] { datasetType, projectName,
                                                                   datasetDescription.statusAsString() });
                                   finished = true;
                                   break;
   
                   }
           }
   
           logger.log(Level.INFO, "Dataset info. Status: {0}\n Message: {1} }",
                           new Object[] { datasetDescription.statusAsString(),
                                           datasetDescription.statusMessage() });
   
           return datasetDescription;
   
   }

3. Entrene su modelo siguiendo los pasos que se indican en Entrenando a un modelo (SDK).