Crear un archivo de manifiesto de clasificación a partir de un CSV archivo

Este script de Python de ejemplo simplifica la creación de un archivo de manifiesto de clasificación mediante el uso de un archivo de valores separados por comas (CSV) para etiquetar las imágenes. Usted crea el CSV archivo.

Un archivo de manifiesto describe las imágenes utilizadas para entrenar un modelo. Un archivo de manifiesto se compone de una o más JSON líneas. Cada JSON línea describe una sola imagen. Para obtener más información, consulte Definir JSON líneas para la clasificación de imágenes.

Un CSV archivo representa datos tabulares en varias filas de un archivo de texto. Los campos de las filas están separados por comas. Para obtener más información, consulte valores separados por comas. En este script, cada fila del CSV archivo incluye la ubicación S3 de una imagen y la clasificación de anomalías de la imagen (normaloanomaly). Cada fila se asigna a una JSON línea del archivo de manifiesto.

Por ejemplo, el siguiente CSV archivo describe algunas de las imágenes de las imágenes de ejemplo.

s3://s3bucket/circuitboard/train/anomaly/train-anomaly_1.jpg,anomaly
s3://s3bucket/circuitboard/train/anomaly/train-anomaly_10.jpg,anomaly
s3://s3bucket/circuitboard/train/anomaly/train-anomaly_11.jpg,anomaly
s3://s3bucket/circuitboard/train/normal/train-normal_1.jpg,normal
s3://s3bucket/circuitboard/train/normal/train-normal_10.jpg,normal
s3://s3bucket/circuitboard/train/normal/train-normal_11.jpg,normal

El script genera JSON líneas para cada fila. Por ejemplo, la siguiente es la JSON línea de la primera fila (s3://s3bucket/circuitboard/train/anomaly/train-anomaly_1.jpg,anomaly).

{"source-ref": "s3://s3bucket/csv_test/train_anomaly_1.jpg","anomaly-label": 1,"anomaly-label-metadata": {"confidence": 1,"job-name": "labeling-job/anomaly-classification","class-name": "anomaly","human-annotated": "yes","creation-date": "2022-02-04T22:47:07","type": "groundtruth/image-classification"}}

Si el CSV archivo no incluye la ruta de Amazon S3 para las imágenes, utilice el argumento de la línea de --s3-path comandos para especificar la ruta de Amazon S3 a las imágenes.

Antes de crear el archivo de manifiesto, el script comprueba si hay imágenes duplicadas en el CSV archivo y cualquier clasificación de imágenes que no normal lo esté. anomaly Si se encuentran imágenes duplicadas o errores de clasificación de imágenes, el script hace lo siguiente:

• Registra la primera entrada de imagen válida para todas las imágenes de un archivo deduplicadoCSV.

• Registra las apariciones duplicadas de una imagen en el archivo de errores.

• Registra las clasificaciones de imágenes que no están en el archivo de errores normal o que están anomaly incluidas en él.

• No crea un archivo de manifiesto.

El archivo de errores incluye el número de línea en el que se encuentra una imagen duplicada o un error de clasificación en el archivo de entradaCSV. Utilice el CSV archivo de errores para actualizar el CSV archivo de entrada y, a continuación, vuelva a ejecutar el script. Como alternativa, utilice el CSV archivo de errores para actualizar el CSV archivo deduplicado, que solo contiene entradas de imágenes únicas e imágenes sin errores de clasificación de imágenes. Vuelva a ejecutar el script con el archivo deduplicado actualizado. CSV

Si no se encuentran duplicados ni errores en el archivo de entrada, el script elimina el CSV archivo de imagen deduplicada y el CSV archivo de errores, ya que están vacíos.

En este procedimiento, se crea el CSV archivo y se ejecuta el script de Python para crear el archivo de manifiesto. El script se ha probado con la versión 3.7 de Python.

Para crear un archivo de manifiesto a partir de un CSV archivo

1. Cree un CSV archivo con los siguientes campos en cada fila (una fila por imagen). No añada una fila de encabezado al CSV archivo.

   Campo 1	Campo 2
   El nombre de la imagen o la ruta de Amazon S3 a la imagen. Por ejemplo, s3://s3bucket/circuitboard/train/anomaly/train-anomaly_10.jpg. No puede haber una mezcla de imágenes con la ruta de Amazon S3 e imágenes sin ella.	La clasificación de anomalías de la imagen (normaloanomaly).

   Por ejemplo, s3://s3bucket/circuitboard/train/anomaly/image_10.jpg,anomaly o image_11.jpg,normal

2. Guarde el archivo CSV.

3. Ejecute el siguiente script de Python. Proporcione los siguientes argumentos:

   • csv_file— El CSV archivo que creó en el paso 1.

   • (Opcional)--s3-path s3://path_to_folder/: la ruta de Amazon S3 que se quiera agregar de los archivos de imagen (campo 1). --s3-pathÚselo si las imágenes del campo 1 aún no contienen una ruta S3.

   # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
   # SPDX-License-Identifier:  Apache-2.0
   """
   Purpose
   Shows how to create an Amazon Lookout for Vision manifest file from a CSV file.
   The CSV file format is image location,anomaly classification (normal or anomaly)
   For example:
   s3://s3bucket/circuitboard/train/anomaly/train_11.jpg,anomaly
   s3://s3bucket/circuitboard/train/normal/train_1.jpg,normal
   
   If necessary, use the bucket argument to specify the Amazon S3 bucket folder for the images.
   """
   
   from datetime import datetime, timezone
   import argparse
   import logging
   import csv
   import os
   import json
   
   logger = logging.getLogger(__name__)
   
   
   def check_errors(csv_file):
       """
       Checks for duplicate images and incorrect classifications in a CSV file.
       If duplicate images or invalid anomaly assignments are found, an errors CSV file
       and deduplicated CSV file are created. Only the first
       occurrence of a duplicate is recorded. Other duplicates are recorded in the errors file.
       :param csv_file: The source CSV file
       :return: True if errors or duplicates are found, otherwise false.
       """
   
       logger.info("Checking %s.", csv_file)
   
       errors_found = False
       errors_file = f"{os.path.splitext(csv_file)[0]}_errors.csv"
       deduplicated_file = f"{os.path.splitext(csv_file)[0]}_deduplicated.csv"
   
       with open(csv_file, 'r', encoding="UTF-8") as input_file,\
               open(deduplicated_file, 'w', encoding="UTF-8") as dedup,\
               open(errors_file, 'w', encoding="UTF-8") as errors:
   
           reader = csv.reader(input_file, delimiter=',')
           dedup_writer = csv.writer(dedup)
           error_writer = csv.writer(errors)
           line = 1
           entries = set()
           for row in reader:
   
               # Skip empty lines.
               if not ''.join(row).strip():
                   continue
   
               # Record any incorrect classifications.
               if not row[1].lower() == "normal" and not row[1].lower() == "anomaly":
                   error_writer.writerow(
                       [line, row[0], row[1], "INVALID_CLASSIFICATION"])
                   errors_found = True
   
               # Write first image entry to dedup file and record duplicates.
               key = row[0]
               if key not in entries:
                   dedup_writer.writerow(row)
                   entries.add(key)
               else:
                   error_writer.writerow([line, row[0], row[1], "DUPLICATE"])
                   errors_found = True
               line += 1
   
       if errors_found:
           logger.info("Errors found check %s.", errors_file)
       else:
           os.remove(errors_file)
           os.remove(deduplicated_file)
   
       return errors_found
   
   
   def create_manifest_file(csv_file, manifest_file, s3_path):
       """
       Read a CSV file and create an Amazon Lookout for Vision classification manifest file.
       :param csv_file: The source CSV file.
       :param manifest_file: The name of the manifest file to create.
       :param s3_path: The Amazon S3 path to the folder that contains the images.
       """
       logger.info("Processing CSV file %s.", csv_file)
   
       image_count = 0
       anomalous_count = 0
   
       with open(csv_file, newline='', encoding="UTF-8") as csvfile,\
           open(manifest_file, "w", encoding="UTF-8") as output_file:
   
           image_classifications = csv.reader(
               csvfile, delimiter=',', quotechar='|')
   
           # Process each row (image) in the CSV file.
           for row in image_classifications:
               # Skip empty lines.
               if not ''.join(row).strip():
                   continue
   
               source_ref = str(s3_path) + row[0]
               classification = 0
   
               if row[1].lower() == 'anomaly':
                   classification = 1
                   anomalous_count += 1
   
              # Create the JSON line.
               json_line = {}
               json_line['source-ref'] = source_ref
               json_line['anomaly-label'] = str(classification)
   
               metadata = {}
               metadata['confidence'] = 1
               metadata['job-name'] = "labeling-job/anomaly-classification"
               metadata['class-name'] = row[1]
               metadata['human-annotated'] = "yes"
               metadata['creation-date'] = datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')
               metadata['type'] = "groundtruth/image-classification"
   
               json_line['anomaly-label-metadata'] = metadata
   
               output_file.write(json.dumps(json_line))
               output_file.write('\n')
               image_count += 1
   
       logger.info("Finished creating manifest file %s.\n"
                   "Images: %s\nAnomalous: %s",
                   manifest_file,
                   image_count,
                   anomalous_count)
       return image_count, anomalous_count
   
   
   def add_arguments(parser):
       """
       Add command line arguments to the parser.
       :param parser: The command line parser.
       """
   
       parser.add_argument(
           "csv_file", help="The CSV file that you want to process."
       )
   
       parser.add_argument(
           "--s3_path", help="The Amazon S3 bucket and folder path for the images."
           " If not supplied, column 1 is assumed to include the Amazon S3 path.", required=False
       )
   
   
   def main():
   
       logging.basicConfig(level=logging.INFO,
                           format="%(levelname)s: %(message)s")
   
       try:
   
           # Get command line arguments.
           parser = argparse.ArgumentParser(usage=argparse.SUPPRESS)
           add_arguments(parser)
           args = parser.parse_args()
           s3_path = args.s3_path
           if s3_path is None:
               s3_path = ""
   
           csv_file = args.csv_file
           csv_file_no_extension = os.path.splitext(csv_file)[0]
           manifest_file = csv_file_no_extension + '.manifest'
   
           # Create manifest file if there are no duplicate images.
           if check_errors(csv_file):
               print(f"Issues found. Use {csv_file_no_extension}_errors.csv "\
                   "to view duplicates and errors.")
               print(f"{csv_file}_deduplicated.csv contains the first"\
                   "occurrence of a duplicate.\n"
                     "Update as necessary with the correct information.")
               print(f"Re-run the script with {csv_file_no_extension}_deduplicated.csv")
           else:
               print('No duplicates found. Creating manifest file.')
   
               image_count, anomalous_count = create_manifest_file(csv_file, manifest_file, s3_path)
   
               print(f"Finished creating manifest file: {manifest_file} \n")
   
               normal_count = image_count-anomalous_count
               print(f"Images processed: {image_count}")
               print(f"Normal: {normal_count}")
               print(f"Anomalous: {anomalous_count}")
   
       except FileNotFoundError as err:
           logger.exception("File not found.:%s", err)
           print(f"File not found: {err}. Check your input CSV file.")
   
   if __name__ == "__main__":
       main()
   
   

4. Si se producen imágenes duplicadas o errores de clasificación:

   1. Utilice el archivo de errores para actualizar el archivo deduplicado o el CSV archivo de entrada. CSV

   2. Vuelva a ejecutar el script con el archivo deduplicado actualizado o el archivo de entrada actualizado. CSV CSV

5. Si planea usar un conjunto de datos de prueba, repita los pasos del 1 al 4 para crear un archivo de manifiesto para su conjunto de datos de prueba.

6. Si es necesario, copie las imágenes de su ordenador a la ruta del bucket de Amazon S3 que especificó en la columna 1 del CSV archivo (o que especificó en la línea de --s3-path comandos). Para copiar las imágenes, ingrese el siguiente comando en el símbolo del sistema.

   aws s3 cp --recursive your-local-folder/ s3://your-target-S3-location/

7. Siga las instrucciones que se indican en Creación de un conjunto de datos con un archivo de manifiesto (consola) para crear un conjunto de datos. Si utiliza el AWS SDK, consulteCrear un conjunto de datos con un archivo de manifiesto (SDK).