

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Erstellen einer Manifestdatei aus einer CSV-Datei
<a name="ex-csv-manifest"></a>

Dieses Python-Beispielskript vereinfacht die Erstellung einer Manifestdatei, indem es eine CSV-Datei (Comma Separated Values) verwendet, um Bilder zu beschriften. So erstellen Sie die CSV-Datei Die Manifestdatei eignet sich für die [Klassifizierung von Bildern mit mehreren Labels](getting-started.md#gs-multi-label-image-classification-example) oder [Bildklassifizierung (mehrere Label)](getting-started.md#gs-multi-label-image-classification-example). Weitere Informationen finden Sie unter [Objekte, Szenen und Konzepte finden](understanding-custom-labels.md#tm-classification). 

**Anmerkung**  
Dieses Skript erstellt keine Manifestdatei, die für die Suche nach [Objektpositionen](understanding-custom-labels.md#tm-object-localization) oder [Markenpositionen](understanding-custom-labels.md#tm-brand-detection-localization) geeignet ist.

Eine Manifestdatei beschreibt die Bilder, die zum Trainieren eines Modells verwendet werden. Zum Beispiel Bildpositionen und Labels, die Bildern zugewiesen wurden. Eine Manifestdatei besteht aus einer oder mehreren JSON-Zeilen. Jede JSON-Zeile beschreibt ein einzelnes Bild. Weitere Informationen finden Sie unter [Labels auf Bildebene in Manifestdateien importieren](md-create-manifest-file-classification.md).

Eine CSV-Datei stellt tabellarische Daten über mehrere Zeilen in einer Textdatei dar. Felder in einer Zeile werden durch ein Komma getrennt. Weitere Informationen finden Sie unter [Kommagetrennte Werte](https://en.wikipedia.org/wiki/Comma-separated_values). Bei diesem Skript steht jede Zeile in Ihrer CSV-Datei für ein einzelnes Bild und ist einer JSON-Zeile in der Manifestdatei zugeordnet. Um eine CSV-Datei für eine Manifestdatei zu erstellen, die die [Bildklassifizierung mit mehreren Labels](getting-started.md#gs-multi-label-image-classification-example) unterstützt, fügen Sie jeder Zeile ein oder mehrere Labels auf Bildebene hinzu. Um eine geeignete Manifestdatei für [Bildklassifizierung](getting-started.md#gs-image-classification-example) zu erstellen, fügen Sie jeder Zeile ein einzelnes Label auf Bildebene hinzu.

In der folgenden CSV-Datei werden beispielsweise die Bilder im Projekt [Bildklassifizierung (mehrere Label)](getting-started.md#gs-multi-label-image-classification-example) (Blumen) *Erste Schritte* beschrieben. 

```
camellia1.jpg,camellia,with_leaves
camellia2.jpg,camellia,with_leaves
camellia3.jpg,camellia,without_leaves
helleborus1.jpg,helleborus,without_leaves,not_fully_grown
helleborus2.jpg,helleborus,with_leaves,fully_grown
helleborus3.jpg,helleborus,with_leaves,fully_grown
jonquil1.jpg,jonquil,with_leaves
jonquil2.jpg,jonquil,with_leaves
jonquil3.jpg,jonquil,with_leaves
jonquil4.jpg,jonquil,without_leaves
mauve_honey_myrtle1.jpg,mauve_honey_myrtle,without_leaves
mauve_honey_myrtle2.jpg,mauve_honey_myrtle,with_leaves
mauve_honey_myrtle3.jpg,mauve_honey_myrtle,with_leaves
mediterranean_spurge1.jpg,mediterranean_spurge,with_leaves
mediterranean_spurge2.jpg,mediterranean_spurge,without_leaves
```

Das Skript generiert JSON-Zeilen für jede Zeile. Das Folgende ist beispielsweise die JSON-Zeile für die erste Zeile (`camellia1.jpg,camellia,with_leaves`).

```
{"source-ref": "s3://bucket/flowers/train/camellia1.jpg","camellia": 1,"camellia-metadata":{"confidence": 1,"job-name": "labeling-job/camellia","class-name": "camellia","human-annotated": "yes","creation-date": "2022-01-21T14:21:05","type": "groundtruth/image-classification"},"with_leaves": 1,"with_leaves-metadata":{"confidence": 1,"job-name": "labeling-job/with_leaves","class-name": "with_leaves","human-annotated": "yes","creation-date": "2022-01-21T14:21:05","type": "groundtruth/image-classification"}}
```

In der Beispiel-CSV ist der Amazon S3-Pfad zum Bild nicht vorhanden. Wenn Ihre CSV-Datei den Amazon S3-Pfad für die Bilder nicht enthält, verwenden Sie das `--s3_path`-Befehlszeilenargument, um den Amazon S3-Pfad zu dem Bild anzugeben. 

Das Skript zeichnet den ersten Eintrag für jedes Bild in einer deduplizierten Bild-CSV-Datei auf. Die CSV-Datei mit dedupliziertem Bild enthält eine einzelne Instance jedes Bildes, das in der CSV-Eingabedatei gefunden wurde. Weitere Vorkommen eines Bilds in der CSV-Eingabedatei werden in einer doppelten CSV-Bilddatei aufgezeichnet. Wenn das Skript doppelte Bilder findet, überprüfen Sie die CSV-Datei mit dem doppelten Bild und aktualisieren Sie die CSV-Datei mit dem deduplizierten Bild nach Bedarf. Führen Sie das Skript mit der deduplizierten Datei erneut aus. Wenn in der CSV-Eingabedatei keine Duplikate gefunden werden, löscht das Skript die deduplizierte CSV-Datei und das duplizierte Bild CSVfile, da sie leer sind. 

 In diesem Verfahren erstellen Sie die CSV-Datei und führen das Python-Skript aus, um die Manifestdatei zu erstellen. 

**So erstellen Sie eine Manifestdatei aus einer CSV-Datei**

1. Erstellen Sie eine CSV-Datei mit den folgenden Feldern in jeder Zeile (eine Zeile pro Bild). Fügen Sie der CSV-Datei keine Kopfzeile hinzu.    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/rekognition/latest/customlabels-dg/ex-csv-manifest.html)

   Zum Beispiel `camellia1.jpg,camellia,with_leaves` oder `s3://my-bucket/flowers/train/camellia1.jpg,camellia,with_leaves` 

1. Speichern Sie die CSV-Datei.

1. Führen Sie das folgende Python-Skript aus. Stellen Sie die folgenden Argumente bereit:
   + `csv_file` – Die CSV-Datei, die Sie in Schritt 1 erstellt haben. 
   + `manifest_file` – Der Name der Manifestdatei, die Sie erstellen möchten.
   + (Optional) `--s3_path s3://path_to_folder/` – Der Amazon S3-Pfad, der den Bilddateinamen hinzugefügt werden soll (Feld 1). Verwenden Sie `--s3_path`, wenn die Bilder in Feld 1 noch keinen S3-Pfad enthalten.

   ```
   # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
   # SPDX-License-Identifier:  Apache-2.0
   
   from datetime import datetime, timezone
   import argparse
   import logging
   import csv
   import os
   import json
   
   """
   Purpose
   Amazon Rekognition Custom Labels model example used in the service documentation.
   Shows how to create an image-level (classification) manifest file from a CSV file.
   You can specify multiple image level labels per image.
   CSV file format is
   image,label,label,..
   If necessary, use the bucket argument to specify the S3 bucket folder for the images.
   https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/md-gt-cl-transform.html
   """
   
   logger = logging.getLogger(__name__)
   
   
   def check_duplicates(csv_file, deduplicated_file, duplicates_file):
       """
       Checks for duplicate images in a CSV file. If duplicate images
       are found, deduplicated_file is the deduplicated CSV file - only the first
       occurence of a duplicate is recorded. Other duplicates are recorded in duplicates_file.
       :param csv_file: The source CSV file.
       :param deduplicated_file: The deduplicated CSV file to create. If no duplicates are found
       this file is removed.
       :param duplicates_file: The duplicate images CSV file to create. If no duplicates are found
       this file is removed.
       :return: True if duplicates are found, otherwise false.
       """
   
       logger.info("Deduplicating %s", csv_file)
   
       duplicates_found = False
   
       # Find duplicates.
       with open(csv_file, 'r', newline='', encoding="UTF-8") as f,\
               open(deduplicated_file, 'w', encoding="UTF-8") as dedup,\
               open(duplicates_file, 'w', encoding="UTF-8") as duplicates:
   
           reader = csv.reader(f, delimiter=',')
           dedup_writer = csv.writer(dedup)
           duplicates_writer = csv.writer(duplicates)
   
           entries = set()
           for row in reader:
               # Skip empty lines.
               if not ''.join(row).strip():
                   continue
   
               key = row[0]
               if key not in entries:
                   dedup_writer.writerow(row)
                   entries.add(key)
               else:
                   duplicates_writer.writerow(row)
                   duplicates_found = True
   
       if duplicates_found:
           logger.info("Duplicates found check %s", duplicates_file)
   
       else:
           os.remove(duplicates_file)
           os.remove(deduplicated_file)
   
       return duplicates_found
   
   
   def create_manifest_file(csv_file, manifest_file, s3_path):
       """
       Reads a CSV file and creates a Custom Labels 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 S3 path to the folder that contains the images.
       """
       logger.info("Processing CSV file %s", csv_file)
   
       image_count = 0
       label_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 CSV file.
           for row in image_classifications:
               source_ref = str(s3_path)+row[0]
   
               image_count += 1
   
               # Create JSON for image source ref.
               json_line = {}
               json_line['source-ref'] = source_ref
   
               # Process each image level label.
               for index in range(1, len(row)):
                   image_level_label = row[index]
   
                   # Skip empty columns.
                   if image_level_label == '':
                       continue
                   label_count += 1
   
                  # Create the JSON line metadata.
                   json_line[image_level_label] = 1
                   metadata = {}
                   metadata['confidence'] = 1
                   metadata['job-name'] = 'labeling-job/' + image_level_label
                   metadata['class-name'] = image_level_label
                   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[f'{image_level_label}-metadata'] = metadata
   
                   # Write the image JSON Line.
               output_file.write(json.dumps(json_line))
               output_file.write('\n')
   
       output_file.close()
       logger.info("Finished creating manifest file %s\nImages: %s\nLabels: %s",
                   manifest_file, image_count, label_count)
   
       return image_count, label_count
   
   
   def add_arguments(parser):
       """
       Adds 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 S3 bucket and folder path for the images."
           " If not supplied, column 1 is assumed to include the 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 = ''
   
           # Create file names.
           csv_file = args.csv_file
           file_name = os.path.splitext(csv_file)[0]
           manifest_file = f'{file_name}.manifest'
           duplicates_file = f'{file_name}-duplicates.csv'
           deduplicated_file = f'{file_name}-deduplicated.csv'
   
           # Create manifest file, if there are no duplicate images.
           if check_duplicates(csv_file, deduplicated_file, duplicates_file):
               print(f"Duplicates found. Use {duplicates_file} to view duplicates "
                     f"and then update {deduplicated_file}. ")
               print(f"{deduplicated_file} contains the first occurence of a duplicate. "
                     "Update as necessary with the correct label information.")
               print(f"Re-run the script with {deduplicated_file}")
           else:
               print("No duplicates found. Creating manifest file.")
   
               image_count, label_count = create_manifest_file(csv_file,
                                                               manifest_file,
                                                               s3_path)
   
               print(f"Finished creating manifest file: {manifest_file} \n"
                     f"Images: {image_count}\nLabels: {label_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()
   ```

1. Wenn Sie einen Testdatensatz verwenden möchten, wiederholen Sie die Schritte 1-3, um eine Manifestdatei für Ihren Testdatensatz zu erstellen.

1. Kopieren Sie die Bilder bei Bedarf in den Amazon-S3-Bucket-Pfad, den Sie in Spalte 1 der CSV-Datei (oder in der `--s3_path`-Befehlszeile) angegeben haben. Sie können folgenden AWS S3-Befehl verwenden.

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

1. [Laden Sie Ihre Manifestdateien](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) in den Amazon-S3-Bucket hoch, den Sie zum Speichern der Manifestdatei verwenden möchten.
**Anmerkung**  
Stellen Sie sicher, dass Amazon Rekognition Custom Labels Zugriff auf den Amazon-S3-Bucket hat, auf den im `source-ref`-Feld der JSON-Zeilen der Manifestdatei verwiesen wird. Weitere Informationen finden Sie unter [Zugreifen auf externe Amazon-S3-Buckets](su-console-policy.md#su-external-buckets). Wenn Ihr Ground Truth-Job Bilder im Amazon Rekognition Custom Labels-Konsolen-Bucket speichert, müssen Sie keine Berechtigungen hinzufügen.

1. Folgen Sie den Anweisungen unter [Erstellen eines Datensatzes mit einer SageMaker AI Ground Truth Manifestdatei (Konsole)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console), um einen Datensatz mit der hochgeladenen Manifestdatei zu erstellen. Geben Sie für Schritt 8 unter **Speicherort der Manifestdatei** die Amazon S3-URL für die Manifestdatei ein. Wenn Sie AWS -SDK verwenden, führen Sie [Erstellen eines Datensatzes mit einer SageMaker AI Ground Truth Manifestdatei (SDK)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk) durch.