Creazione di un file manifesto di classificazione da un file CSV

Questo esempio di script Python semplifica la creazione di un file manifesto di classificazione utilizzando un file CSV (Comma Separated Values) per etichettare le immagini. Creare il file CSV

Un file manifest descrive le immagini utilizzate per addestrare un modello. Un file manifest è costituito da una o più righe JSON. Ogni riga JSON descrive una singola immagine. Per ulteriori informazioni, consulta Definizione delle righe JSON per la classificazione delle immagini.

Un file CSV rappresenta dati tabulari su più righe in un file di testo. I campi in una riga sono separati da una virgola. Per ulteriori informazioni, consultare valori separati da virgola. Per questo script, ogni riga del file CSV include la posizione S3 di un'immagine e la classificazione delle anomalie per l'immagine (o). normal anomaly Ogni riga corrisponde a una riga JSON nel file manifest.

Ad esempio, il seguente file CSV descrive alcune delle immagini contenute nelle immagini di esempio.


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

Lo script genera righe JSON per ogni riga. Ad esempio, quanto segue è una riga JSON per la prima riga (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"}}

Se il tuo file CSV non include il percorso Amazon S3 per le immagini, usa l'argomento della riga di comando per specificare --s3-path il percorso Amazon S3 verso le immagini.

Prima di creare il file manifest, lo script verifica la presenza di immagini duplicate nel file CSV e tutte le classificazioni di immagini che non sono o. normal anomaly Se vengono rilevati duplicati di immagini o errori di classificazione delle immagini, lo script esegue le seguenti operazioni:

Registra la prima voce valida per tutte le immagini in un file CSV deduplicato.
Registra le occorrenze duplicate di un'immagine nel file degli errori.
Registra le classificazioni delle immagini non presenti normal o presenti anomaly nel file degli errori.
Non crea un file manifesto.

Il file degli errori include il numero di riga in cui si trova un'immagine duplicata o un errore di classificazione nel file CSV di input. Utilizza il file CSV degli errori per aggiornare il file CSV di input, quindi esegui nuovamente lo script. In alternativa, utilizza il file CSV degli errori per aggiornare il file CSV deduplicato, che contiene solo voci di immagine uniche e immagini senza errori di classificazione delle immagini. Esegui nuovamente lo script con il file CSV deduplicato aggiornato.

Se non vengono rilevati duplicati o errori nel file CSV di input, lo script elimina il file CSV di immagine deduplicata e il file degli errori, poiché sono vuoti.

In questa procedura, creare il file CSV ed eseguire lo script Python per creare il file manifest. Lo script è stato testato con Python versione 3.7.

Creare un file manifest da un file CSV

Crea un file CSV con i seguenti campi in ogni riga (una riga per immagine). Non aggiungere una riga di intestazione al file CSV.

Campo 1	Campo 2
Il nome dell'immagine o il percorso Amazon S3 all'immagine. Ad esempio, `s3://s3bucket/circuitboard/train/anomaly/train-anomaly_10.jpg`. Non si può avere una combinazione tra immagini con il percorso Amazon S3 e senza.	La classificazione delle anomalie per l'immagine (`normal`o). `anomaly`

Ad esempio, s3://s3bucket/circuitboard/train/anomaly/image_10.jpg,anomaly o image_11.jpg,normal

Salvare il file CSV.

Eseguire il seguente Python script. Fornire gli argomenti seguenti:

csv_file: il file CVS che si è creato nella fase 1.
(Facoltativo)--s3-path s3://path_to_folder/: il percorso Amazon S3 da aggiungere ai nomi dei file immagine (campo 1). Utilizzare --s3-path se le immagini nel campo 1 non contengono già un percorso 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()

Se si verificano immagini duplicate o si verificano errori di classificazione:
1. Utilizzate il file degli errori per aggiornare il file CSV deduplicato o il file CSV di input.
2. Esegui nuovamente lo script con il file CSV deduplicato aggiornato o il file CSV di input aggiornato.
Se intendi utilizzare un set di dati di test, ripeti i passaggi da 1 a 4 per creare un file manifest per il set di dati di test.
Se necessario, copia le immagini dal tuo computer nel percorso del bucket Amazon S3 specificato nella colonna 1 del file CSV (o specificato nella --s3-path riga di comando). Per copiare le immagini, inserisci il seguente comando al prompt dei comandi.
```
aws s3 cp --recursive your-local-folder/ s3://your-target-S3-location/
```
Segui le istruzioni riportate Creazione di un set di dati con un file manifest (console) per creare un set di dati. Se utilizzi l'AWSSDK, consulta. Creazione di un set di dati con un file manifest (SDK)

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Definizione delle righe JSON per la segmentazione delle immagini

Creazione di un set di dati con un file manifest (console)