Création d'un fichier manifeste de classification à partir d'un CSV fichier

Cet exemple de script Python simplifie la création d'un fichier manifeste de classification en utilisant un fichier de valeurs séparées par des virgules (CSV) pour étiqueter les images. Vous créez le CSV fichier.

Un fichier manifeste décrit les images utilisées pour entraîner un modèle Un fichier manifeste est composé d'une ou de plusieurs JSON lignes. Chaque JSON ligne décrit une seule image. Pour de plus amples informations, veuillez consulter Définition de JSON lignes pour la classification des images.

Un CSV fichier représente des données tabulaires réparties sur plusieurs lignes d'un fichier texte. Les champs sur une ligne sont séparés par une virgule. Pour plus d’informations, consultez la section Valeurs séparées par des virgules. Pour ce script, chaque ligne de votre CSV fichier inclut l'emplacement S3 d'une image et la classification des anomalies pour l'image (normalouanomaly). Chaque ligne correspond à une JSON ligne du fichier manifeste.

Par exemple, le CSV fichier suivant décrit certaines des images contenues dans les exemples d'images.

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

Le script génère JSON des lignes pour chaque ligne. Par exemple, voici la JSON ligne de la première ligne (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 votre CSV fichier n'inclut pas le chemin Amazon S3 pour les images, utilisez l'argument de ligne de --s3-path commande pour spécifier le chemin Amazon S3 vers les images.

Avant de créer le fichier manifeste, le script vérifie la présence d'images dupliquées dans le CSV fichier ainsi que toutes les classifications d'images qui ne le sont pas normal ouanomaly. Si des doublons ou des erreurs de classification d'images sont détectées, le script effectue les opérations suivantes :

• Enregistre la première entrée d'image valide pour toutes les images d'un fichier dédupliqué. CSV

• Enregistre les occurrences de doublons d'une image dans le fichier d'erreurs.

• Enregistre les classifications d'images qui ne figurent pas anomaly dans le fichier d'erreurs normal ou qui ne le sont pas.

• Ne crée pas de fichier manifeste.

Le fichier d'erreurs inclut le numéro de ligne où une image dupliquée ou une erreur de classification est détectée dans le CSV fichier d'entrée. Utilisez le CSV fichier d'erreurs pour mettre à jour le CSV fichier d'entrée, puis réexécutez le script. Vous pouvez également utiliser le CSV fichier d'erreurs pour mettre à jour le CSV fichier dédupliqué, qui contient uniquement des entrées d'image uniques et des images sans erreur de classification des images. Réexécutez le script avec le fichier dédupliqué CSV mis à jour.

Si aucun doublon ou aucune erreur n'est détecté dans le CSV fichier d'entrée, le script supprime le fichier image dédupliqué et le CSV fichier d'erreurs, car ils sont vides.

Dans cette procédure, vous créez le CSV fichier et exécutez le script Python pour créer le fichier manifeste. Le script a été testé avec la version 3.7 de Python.

Pour créer un fichier manifeste à partir d'un CSV fichier

1. Créez un CSV fichier avec les champs suivants dans chaque ligne (une ligne par image). N'ajoutez pas de ligne d'en-tête au CSV fichier.

   Champ 1	Champ 2
   Nom de l’image ou chemin Amazon S3 de l’image. Par exemple, s3://s3bucket/circuitboard/train/anomaly/train-anomaly_10.jpg. Vous ne pouvez pas avoir à la fois des images avec le chemin Amazon S3 et des images sans ce chemin.	Classification des anomalies pour l'image (normalouanomaly).

   Par exemple : s3://s3bucket/circuitboard/train/anomaly/image_10.jpg,anomaly ou image_11.jpg,normal

2. Enregistrez le fichier CSV.

3. Exécutez le script Python suivant. Fournissez les arguments suivants :

   • csv_file— Le CSV fichier que vous avez créé à l'étape 1.

   • (Facultatif) --s3-path s3://path_to_folder/ : chemin Amazon S3 à ajouter aux noms de fichiers image (champ 1). Utilisez --s3-path si les images du champ 1 ne contiennent pas déjà de chemin 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. En cas de duplication d'images ou d'erreurs de classification :

   1. Utilisez le fichier d'erreurs pour mettre à jour le fichier dédupliqué ou CSV le fichier d'entrée. CSV

   2. Réexécutez le script avec le fichier dédupliqué ou le CSV fichier d'entrée CSV mis à jour.

5. Si vous prévoyez d'utiliser un ensemble de données de test, répétez les étapes 1 à 4 pour créer un fichier manifeste pour votre ensemble de données de test.

6. Si nécessaire, copiez les images de votre ordinateur vers le chemin du compartiment Amazon S3 que vous avez spécifié dans la colonne 1 du CSV fichier (ou indiqué dans la ligne de --s3-path commande). Pour copier les images, entrez la commande suivante à l'invite de commande.

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

7. Suivez les instructions de l'adresse Création d'un ensemble de données avec un fichier manifeste (console) pour créer un jeu de données. Si vous utilisez le AWS SDK, consultezCréation d'un ensemble de données avec un fichier manifeste (SDK).