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. # Konvertierung anderer Datensatzformate in eine Manifestdatei Sie können die folgenden Informationen verwenden, um Manifestdateien im Amazon SageMaker AI-Format aus einer Vielzahl von Quelldatensatzformaten zu erstellen. Nachdem Sie die Manifestdatei erstellt haben, verwenden Sie sie, um einen Datensatz zu erstellen. Weitere Informationen finden Sie unter [Verwenden einer Manifestdatei zum Importieren von Bildern](md-create-dataset-ground-truth.md). **Topics** + [Umwandlung eines COCO-Datensatzes in ein Manifest-Dateiformat](md-transform-coco.md) + [Transformation von SageMaker AI Ground Truth-Manifestdateien mit mehreren Labels](md-gt-cl-transform.md) + [Erstellen einer Manifestdatei aus einer CSV-Datei](ex-csv-manifest.md) # Umwandlung eines COCO-Datensatzes in ein Manifest-Dateiformat [COCO](http://cocodataset.org/#home) ist ein Format zur Spezifizierung umfangreicher Datensätze zur Objekterkennung, Segmentierung und Untertitelung. Dieses Python-[Beispiel](md-coco-transform-example.md) zeigt Ihnen, wie Sie einen Datensatz im COCO-Objekterkennungsformat in eine [Manifestdatei im Begrenzungsrahmen-Format](md-create-manifest-file-object-detection.md) Amazon Rekognition Custom Labels umwandeln. Dieser Abschnitt enthält auch Informationen, mit denen Sie Ihren eigenen Code schreiben können. Eine JSON-Datei im COCO-Format besteht aus fünf Abschnitten, die Informationen für *einen gesamten Datensatz* enthalten. Weitere Informationen finden Sie unter [Das COCO-Datensatzformat](md-coco-overview.md). + `info` — allgemeine Informationen über den Datensatz. + `licenses ` — Lizenzinformationen für die Bilder im Datensatz. + [`images`](md-coco-overview.md#md-coco-images) — eine Liste der Bilder im Datensatz. + [`annotations`](md-coco-overview.md#md-coco-annotations) — eine Liste von Anmerkungen (einschließlich Begrenzungsrahmen), die in allen Bildern des Datensatzes vorhanden sind. + [`categories`](md-coco-overview.md#md-coco-categories) — eine Liste von Label-Kategorien. Sie benötigen Informationen aus den Listen `images`, `annotations` und `categories`, um eine Amazon Rekognition Custom Labels-Manifestdatei zu erstellen. Eine Amazon Rekognition Custom Labels-Manifestdatei hat das JSON-Zeilenformat, wobei jede Zeile den Begrenzungsrahmen und die Labelinformationen für ein oder mehrere Objekte *auf einem Bild* enthält. Weitere Informationen finden Sie unter [Objektlokalisierung in Manifestdateien](md-create-manifest-file-object-detection.md). ## Zuordnung von COCO-Objekten zu einer JSON-Zeile mit benutzerdefinierten Labels Um einen Datensatz im COCO-Format zu transformieren, ordnen Sie den COCO-Datensatz einer Amazon Rekognition Custom Labels-Manifestdatei für die Objektlokalisierung zu. Weitere Informationen finden Sie unter [Objektlokalisierung in Manifestdateien](md-create-manifest-file-object-detection.md). Um für jedes Bild eine JSON-Zeile zu erstellen, muss die Manifestdatei den COCO-Datensatz `image` und `category` das Objektfeld zuordnen IDs. `annotation` Folgendes ist ein Beispiel für den Inhalt einer COCO-Manifestdatei: Weitere Informationen finden Sie unter [Das COCO-Datensatzformat](md-coco-overview.md). ``` { "info": { "description": "COCO 2017 Dataset","url": "http://cocodataset.org","version": "1.0","year": 2017,"contributor": "COCO Consortium","date_created": "2017/09/01" }, "licenses": [ {"url": "http://creativecommons.org/licenses/by/2.0/","id": 4,"name": "Attribution License"} ], "images": [ {"id": 242287, "license": 4, "coco_url": "http://images.cocodataset.org/val2017/xxxxxxxxxxxx.jpg", "flickr_url": "http://farm3.staticflickr.com/2626/xxxxxxxxxxxx.jpg", "width": 426, "height": 640, "file_name": "xxxxxxxxx.jpg", "date_captured": "2013-11-15 02:41:42"}, {"id": 245915, "license": 4, "coco_url": "http://images.cocodataset.org/val2017/nnnnnnnnnnnn.jpg", "flickr_url": "http://farm1.staticflickr.com/88/xxxxxxxxxxxx.jpg", "width": 640, "height": 480, "file_name": "nnnnnnnnnn.jpg", "date_captured": "2013-11-18 02:53:27"} ], "annotations": [ {"id": 125686, "category_id": 0, "iscrowd": 0, "segmentation": [[164.81, 417.51,......167.55, 410.64]], "image_id": 242287, "area": 42061.80340000001, "bbox": [19.23, 383.18, 314.5, 244.46]}, {"id": 1409619, "category_id": 0, "iscrowd": 0, "segmentation": [[376.81, 238.8,........382.74, 241.17]], "image_id": 245915, "area": 3556.2197000000015, "bbox": [399, 251, 155, 101]}, {"id": 1410165, "category_id": 1, "iscrowd": 0, "segmentation": [[486.34, 239.01,..........495.95, 244.39]], "image_id": 245915, "area": 1775.8932499999994, "bbox": [86, 65, 220, 334]} ], "categories": [ {"supercategory": "speaker","id": 0,"name": "echo"}, {"supercategory": "speaker","id": 1,"name": "echo dot"} ] } ``` Das folgende Diagramm zeigt, wie die COCO-Datensatzlisten für einen *Datensatz* den JSON-Zeilen von Amazon Rekognition Custom Labels für ein *Bild* zugeordnet werden. Jede JSON-Zeile für ein Bild besitzt ein Quellverweis-, Job- und Job-Metadatenfeld. Übereinstimmende Farben geben Informationen für ein einzelnes Bild an. Beachten Sie, dass ein einzelnes Bild im Manifest mehrere Anmerkungen und Metadaten/Kategorien haben kann. ![\[Diagramm, das die Struktur von Coco Manifest mit Bildern, Anmerkungen und Kategorien zeigt.\]](http://docs.aws.amazon.com/de_de/rekognition/latest/customlabels-dg/images/coco-transform.png) **So rufen Sie die COCO-Objekte für eine einzelne JSON-Zeile ab** 1. Rufen Sie für jedes Bild in der Bilderliste die Anmerkung aus der Anmerkungsliste ab, bei der der Wert des Anmerkungsfeldes `image_id` mit dem `id`-Bildfeld übereinstimmt. 1. Lesen Sie für jede Anmerkung, die in Schritt 1 gefunden wurde, die `categories`-Liste durch und ermitteln Sie jede `category`, bei der der Wert des `category`-Feldes `id` mit dem `annotation` `category_id`-Objektfeld übereinstimmt. 1. Erstellen Sie mithilfe der übereinstimmenden Objekte `image`, `annotation` und `category` eine JSON-Zeile für das Bild. Informationen zur Zuordnung der Felder finden Sie unter [Zuordnen von COCO-Objektfeldern zu JSON-Zeilenobjektfeldern mit benutzerdefinierten Labels](#md-mapping-fields-coco). 1. Wiederholen Sie die Schritte 1-3, bis Sie für jedes `image`-Objekt in der `images`-Liste JSON-Zeilen erstellt haben. Einen Beispielcode finden Sie unter [Transformieren eines COCO-Datensatzes](md-coco-transform-example.md). ## Zuordnen von COCO-Objektfeldern zu JSON-Zeilenobjektfeldern mit benutzerdefinierten Labels Nachdem Sie die COCO-Objekte für eine Amazon Rekognition Custom Labels JSON-Zeile identifiziert haben, müssen Sie die COCO-Objektfelder den jeweiligen JSON-Zeilenobjektfeldern von Amazon Rekognition Custom Labels zuordnen. Die folgende JSON-Beispielzeile für Amazon Rekognition Custom Labels ordnet ein Bild (`id`=`000000245915`) dem vorherigen COCO-JSON-Beispiel zu. Notieren Sie die folgenden Informationen: + `source-ref` ist der Speicherort des Images in einem Amazon-S3-Bucket. Wenn Ihre COCO-Bilder nicht in einem Amazon-S3-Bucket gespeichert sind, müssen Sie sie in einen Amazon-S3-Bucket verschieben. + Die `annotations`-Liste enthält ein `annotation`-Objekt für jedes Objekt auf dem Bild. Ein `annotation`-Objekt enthält Informationen zum Begrenzungsrahmen (`top`,`left`,`width`,`height`) und eine Label-ID (`class_id`). + Die Label-ID (`class_id`) ist der `class-map`-Liste in den Metadaten zugeordnet. Sie listet die auf dem Bild verwendeten Labels auf. ``` { "source-ref": "s3://custom-labels-bucket/images/000000245915.jpg", "bounding-box": { "image_size": { "width": 640, "height": 480, "depth": 3 }, "annotations": [{ "class_id": 0, "top": 251, "left": 399, "width": 155, "height": 101 }, { "class_id": 1, "top": 65, "left": 86, "width": 220, "height": 334 }] }, "bounding-box-metadata": { "objects": [{ "confidence": 1 }, { "confidence": 1 }], "class-map": { "0": "Echo", "1": "Echo Dot" }, "type": "groundtruth/object-detection", "human-annotated": "yes", "creation-date": "2018-10-18T22:18:13.527256", "job-name": "my job" } } ``` Verwenden Sie die folgenden Informationen, um die Felder der Amazon Rekognition Custom Labels-Manifestdatei den JSON-Feldern des COCO-Datensatzes zuzuordnen. ### Quellennachweis Die URL im S3-Format für den Speicherort des Bildes. Das Video muss in einem S3-Bucket gespeichert sein. Weitere Informationen finden Sie unter [Quellennachweis](md-create-manifest-file-object-detection.md#cd-manifest-source-ref). Wenn das `coco_url`-COCO-Feld auf eine S3-Bucket-Position verweist, können Sie den Wert von `coco_url` für den Wert von `source-ref` verwenden. Alternativ können Sie das Feld `source-ref` dem Feld `file_name` (COCO) zuordnen und in Ihrem Transformationscode den erforderlichen S3-Pfad zu dem Speicherort des Bilds hinzufügen. ### *bounding-box* Ein Label-Attributname Ihrer Wahl. Weitere Informationen finden Sie unter [*bounding-box*](md-create-manifest-file-object-detection.md#md-manifest-source-bounding-box). #### Bildgröße Die Größe des Bildes in MB Ordnet einem `image`-Objekt in der [Bilder](md-coco-overview.md#md-coco-images)-Liste zu. + `height`-> `image.height` + `width`-> `image.width` + `depth`-> Wird nicht von Amazon Rekognition Custom Labels verwendet, aber es muss ein Wert angegeben werden. #### Anmerkungen Eine Liste von `annotation`-Objekten. Für jedes Objekt auf dem Bild gibt es einen `annotation`. #### Anmerkung Enthält Begrenzungsrahmen für eine Instance eines Objekts auf dem Bild. + `class_id`-> Zuordnung einer numerischen ID zur `class-map`-Liste von Custom Label. + `top` -> `bbox[1]` + `left` -> `bbox[0]` + `width` -> `bbox[2]` + `height` -> `bbox[3]` ### *bounding-box*-Metadaten Metadaten für das Label-Attribut. Beinhaltet die Labels und Label-IDs. Weitere Informationen finden Sie unter [*bounding-box*-Metadaten](md-create-manifest-file-object-detection.md#md-manifest-source-bounding-box-metadata). #### Objekte Ein Array von Objekten im Bild. Ordnet der `annotations`-Liste nach Index zu. ##### Objekt + `confidence`->Wird nicht von Amazon Rekognition Custom Labels verwendet, aber ein Wert (1) ist erforderlich. #### Klassenzuordnung Eine Übersicht der Labels (Klassen), die für die im Bild erkannten Objekte gelten. Ordnet Kategorieobjekten in der [Kategorien](md-coco-overview.md#md-coco-categories)-Liste zu. + `id` -> `category.id` + `id value` -> `category.name` #### type Muss `groundtruth/object-detection` sein. #### mit menschlichen Anmerkungen versehen Geben Sie `yes` oder `no` an. Weitere Informationen finden Sie unter [*bounding-box*-Metadaten](md-create-manifest-file-object-detection.md#md-manifest-source-bounding-box-metadata). #### Erstellungsdatum -> [Bild](md-coco-overview.md#md-coco-images).Aufnahmedatum Das Erstellungsdatum und der Erstellungszeitpunkt des Bildes. Ordnet dem Feld [Bild](md-coco-overview.md#md-coco-images).Aufnahmedatum eines Bildes in der COCO-Bilderliste zu. Amazon Rekognition Custom Labels erwartet, dass das Format von `creation-date` *Y-M-DTH:M:S* lautet. #### Jobname Ein Jobname Ihrer Wahl. # Das COCO-Datensatzformat Ein COCO-Datensatz besteht aus fünf Informationsabschnitten, die Informationen für den gesamten Datensatz enthalten. Das Format für einen Datensatz zur COCO-Objekterkennung ist im [COCO-Datenformat](http://cocodataset.org/#format-data) dokumentiert. + Info – allgemeine Informationen über den Datensatz. + licenses – Lizenzinformationen für die Bilder im Datensatz. + [images](#md-coco-images) – eine Liste der Bilder im Datensatz. + [annotations](#md-coco-annotations) – eine Liste von Anmerkungen (einschließlich Begrenzungsrahmen), die in allen Bildern im Datensatz vorhanden sind. + [categories](#md-coco-categories) – eine Liste von Label-Kategorien. Um ein Manifest für benutzerdefinierte Labels zu erstellen, verwenden Sie die Listen `images`, `annotations` und `categories` aus der COCO-Manifestdatei. Die anderen Abschnitte (`info`,`licences`) sind nicht erforderlich. Folgendes ist ein Beispiel für den Inhalt einer COCO-Manifestdatei. ``` { "info": { "description": "COCO 2017 Dataset","url": "http://cocodataset.org","version": "1.0","year": 2017,"contributor": "COCO Consortium","date_created": "2017/09/01" }, "licenses": [ {"url": "http://creativecommons.org/licenses/by/2.0/","id": 4,"name": "Attribution License"} ], "images": [ {"id": 242287, "license": 4, "coco_url": "http://images.cocodataset.org/val2017/xxxxxxxxxxxx.jpg", "flickr_url": "http://farm3.staticflickr.com/2626/xxxxxxxxxxxx.jpg", "width": 426, "height": 640, "file_name": "xxxxxxxxx.jpg", "date_captured": "2013-11-15 02:41:42"}, {"id": 245915, "license": 4, "coco_url": "http://images.cocodataset.org/val2017/nnnnnnnnnnnn.jpg", "flickr_url": "http://farm1.staticflickr.com/88/xxxxxxxxxxxx.jpg", "width": 640, "height": 480, "file_name": "nnnnnnnnnn.jpg", "date_captured": "2013-11-18 02:53:27"} ], "annotations": [ {"id": 125686, "category_id": 0, "iscrowd": 0, "segmentation": [[164.81, 417.51,......167.55, 410.64]], "image_id": 242287, "area": 42061.80340000001, "bbox": [19.23, 383.18, 314.5, 244.46]}, {"id": 1409619, "category_id": 0, "iscrowd": 0, "segmentation": [[376.81, 238.8,........382.74, 241.17]], "image_id": 245915, "area": 3556.2197000000015, "bbox": [399, 251, 155, 101]}, {"id": 1410165, "category_id": 1, "iscrowd": 0, "segmentation": [[486.34, 239.01,..........495.95, 244.39]], "image_id": 245915, "area": 1775.8932499999994, "bbox": [86, 65, 220, 334]} ], "categories": [ {"supercategory": "speaker","id": 0,"name": "echo"}, {"supercategory": "speaker","id": 1,"name": "echo dot"} ] } ``` ## Liste der Bilder Die Bilder, auf die in einem COCO-Datensatz verwiesen wird, sind im Bilderarray aufgeführt. Jedes Bildobjekt enthält Informationen über das Bild, z. B. den Namen der Bilddatei. Notieren Sie sich im folgenden Beispiel-Bildobjekt die folgenden Informationen und welche Felder erforderlich sind, um eine Amazon Rekognition Custom Labels-Manifestdatei zu erstellen. + `id` – (Erforderlich) Eine eindeutige Kennung für das Bild. Das `id`-Feld ist dem `id`-Feld im Annotationsarray zugeordnet (in dem Begrenzungsrahmen-Informationen gespeichert werden). + `license` – (Nicht erforderlich) Entspricht dem Lizenz-Array. + `coco_url` – (Optional) Den Speicherort des Bildes. + `flickr_url` – (Nicht erforderlich) Der Speicherort des Bildes auf Flickr. + `width` – (Erforderlich) Die Breite des Bildes. + `height` – (Erforderlich) Die Höhe des Bildes. + `file_name` – (Erforderlich) Der Name der Bilddatei. In diesem Beispiel stimmen `file_name` und `id` überein, aber das ist keine Voraussetzung für COCO-Datensätze. + `date_captured` – (Erforderlich) Datum und Uhrzeit der Aufnahme des Bildes. ``` { "id": 245915, "license": 4, "coco_url": "http://images.cocodataset.org/val2017/nnnnnnnnnnnn.jpg", "flickr_url": "http://farm1.staticflickr.com/88/nnnnnnnnnnnnnnnnnnn.jpg", "width": 640, "height": 480, "file_name": "000000245915.jpg", "date_captured": "2013-11-18 02:53:27" } ``` ## Liste der Anmerkungen (Begrenzungsfelder) Die Begrenzungsrahmeninformationen für alle Objekte auf allen Bildern werden in der Liste der Anmerkungen gespeichert. Ein einzelnes Anmerkungsobjekt enthält Begrenzungsrahmeninformationen für ein einzelnes Objekt und die Bezeichnung des Objekts auf einem Bild. Für jede Instance eines Objekts auf einem Bild gibt es ein Anmerkungsobjekt. Notieren Sie sich im folgenden Beispiel die folgenden Informationen und welche Felder erforderlich sind, um eine Amazon Rekognition Custom Labels-Manifestdatei zu erstellen. + `id` – (Nicht erforderlich) Die Kennung für die Anmerkung. + `image_id` – (Erforderlich) Entspricht dem Bild `id` im Bildarray. + `category_id` – (Erforderlich) Der Bezeichner für das Label, das das Objekt innerhalb eines Begrenzungsrahmens identifiziert. Er wird dem `id`-Feld des Kategorien-Arrays zugeordnet. + `iscrowd` – (Nicht erforderlich) Gibt an, ob das Bild eine Menge von Objekten enthält. + `segmentation` – (Nicht erforderlich) Segmentierungsinformationen für Objekte auf einem Bild. Amazon Rekognition Custom Labels unterstützt keine Segmentierung. + `area` – (Nicht erforderlich) Der Bereich der Anmerkung. + `bbox` – (Erforderlich) Enthält die Koordinaten eines Begrenzungsrahmens, der ein Objekt auf dem Bild umgibt, in Pixeln. ``` { "id": 1409619, "category_id": 1, "iscrowd": 0, "segmentation": [ [86.0, 238.8,..........382.74, 241.17] ], "image_id": 245915, "area": 3556.2197000000015, "bbox": [86, 65, 220, 334] } ``` ## Liste der Kategorien Labelinformationen werden im Kategorien-Array gespeichert. Notieren Sie sich im folgenden Beispiel für ein Kategorie-Objekt die folgenden Informationen und welche Felder erforderlich sind, um eine Amazon Rekognition Custom Labels-Manifestdatei zu erstellen. + `supercategory` – (Nicht erforderlich) Die übergeordnete Kategorie für ein Label. + `id` – (Erforderlich) Die Label-ID. Das `id`-Feld ist dem `category_id`-Feld in einem `annotation`-Objekt zugeordnet. Im folgenden Beispiel ist der Identifier für einen Echo Dot 2. + `name` – (Erforderlich) Der Labelname. ``` {"supercategory": "speaker","id": 2,"name": "echo dot"} ``` # Transformieren eines COCO-Datensatzes Verwenden Sie das folgende Python-Beispiel, um Begrenzungsrahmen-Informationen aus einem Datensatz im COCO-Format in eine Amazon Rekognition Custom Labels-Manifestdatei umzuwandeln. Der Code lädt die erstellte Manifestdatei in Ihren Amazon-S3-Bucket hoch. Der Code stellt auch einen AWS CLI-Befehl bereit, mit dem Sie Ihre Bilder hochladen können. **So transformieren Sie einen COCO-Datensatz (SDK)** 1. Wenn Sie dies noch nicht getan haben: 1. Stellen Sie sicher, dass Sie die folgenden `AmazonS3FullAccess`-Berechtigungen haben. Weitere Informationen finden Sie unter [Einrichten von SDK-Berechtigungen](su-sdk-permissions.md). 1. Installieren und konfigurieren Sie das AWS CLI und das AWS SDKs. Weitere Informationen finden Sie unter [Schritt 4: Richten Sie das und ein AWS CLI AWS SDKs](su-awscli-sdk.md). 1. Verwenden Sie den folgenden Python-Code, um einen COCO-Datensatz zu transformieren. Legen Sie die folgenden Werte fest. + `s3_bucket` – Der Name des S3-Buckets, in dem Sie die Bilder und die Amazon Rekognition Custom Labels-Manifestdatei speichern möchten. + `s3_key_path_images` – Der Pfad zu dem Ort, an dem Sie die Bilder innerhalb des S3-Buckets platzieren möchten (`s3_bucket`). + `s3_key_path_manifest_file` – Der Pfad zu der Stelle, an der Sie die Manifestdatei für benutzerdefinierte Labels im S3-Bucket platzieren möchten (`s3_bucket`). + `local_path` – Der lokale Pfad, in dem das Beispiel den COCO-Eingabedatensatz öffnet und auch die neue Custom Labels-Manifestdatei speichert. + `local_images_path` – Der lokale Pfad zu den Bildern, die Sie für das Training verwenden möchten. + `coco_manifest` – Der Dateiname des COCO-Eingabedatensatzes. + `cl_manifest_file` – Ein Name für die Manifestdatei, die durch das Beispiel erstellt wurde. Die Datei wird an dem von `local_path` angegebenen Speicherort gespeichert. Konventionell hat die Datei die Erweiterung `.manifest`, dies ist jedoch nicht erforderlich. + `job_name` – Ein Name für den Custom Labels-Job. ``` import json import os import random import shutil import datetime import botocore import boto3 import PIL.Image as Image import io #S3 location for images s3_bucket = 'bucket' s3_key_path_manifest_file = 'path to custom labels manifest file/' s3_key_path_images = 'path to images/' s3_path='s3://' + s3_bucket + '/' + s3_key_path_images s3 = boto3.resource('s3') #Local file information local_path='path to input COCO dataset and output Custom Labels manifest/' local_images_path='path to COCO images/' coco_manifest = 'COCO dataset JSON file name' coco_json_file = local_path + coco_manifest job_name='Custom Labels job name' cl_manifest_file = 'custom_labels.manifest' label_attribute ='bounding-box' open(local_path + cl_manifest_file, 'w').close() # class representing a Custom Label JSON line for an image class cl_json_line: def __init__(self,job, img): #Get image info. Annotations are dealt with seperately sizes=[] image_size={} image_size["width"] = img["width"] image_size["depth"] = 3 image_size["height"] = img["height"] sizes.append(image_size) bounding_box={} bounding_box["annotations"] = [] bounding_box["image_size"] = sizes self.__dict__["source-ref"] = s3_path + img['file_name'] self.__dict__[job] = bounding_box #get metadata metadata = {} metadata['job-name'] = job_name metadata['class-map'] = {} metadata['human-annotated']='yes' metadata['objects'] = [] date_time_obj = datetime.datetime.strptime(img['date_captured'], '%Y-%m-%d %H:%M:%S') metadata['creation-date']= date_time_obj.strftime('%Y-%m-%dT%H:%M:%S') metadata['type']='groundtruth/object-detection' self.__dict__[job + '-metadata'] = metadata print("Getting image, annotations, and categories from COCO file...") with open(coco_json_file) as f: #Get custom label compatible info js = json.load(f) images = js['images'] categories = js['categories'] annotations = js['annotations'] print('Images: ' + str(len(images))) print('annotations: ' + str(len(annotations))) print('categories: ' + str(len (categories))) print("Creating CL JSON lines...") images_dict = {image['id']: cl_json_line(label_attribute, image) for image in images} print('Parsing annotations...') for annotation in annotations: image=images_dict[annotation['image_id']] cl_annotation = {} cl_class_map={} # get bounding box information cl_bounding_box={} cl_bounding_box['left'] = annotation['bbox'][0] cl_bounding_box['top'] = annotation['bbox'][1] cl_bounding_box['width'] = annotation['bbox'][2] cl_bounding_box['height'] = annotation['bbox'][3] cl_bounding_box['class_id'] = annotation['category_id'] getattr(image, label_attribute)['annotations'].append(cl_bounding_box) for category in categories: if annotation['category_id'] == category['id']: getattr(image, label_attribute + '-metadata')['class-map'][category['id']]=category['name'] cl_object={} cl_object['confidence'] = int(1) #not currently used by Custom Labels getattr(image, label_attribute + '-metadata')['objects'].append(cl_object) print('Done parsing annotations') # Create manifest file. print('Writing Custom Labels manifest...') for im in images_dict.values(): with open(local_path+cl_manifest_file, 'a+') as outfile: json.dump(im.__dict__,outfile) outfile.write('\n') outfile.close() # Upload manifest file to S3 bucket. print ('Uploading Custom Labels manifest file to S3 bucket') print('Uploading' + local_path + cl_manifest_file + ' to ' + s3_key_path_manifest_file) print(s3_bucket) s3 = boto3.resource('s3') s3.Bucket(s3_bucket).upload_file(local_path + cl_manifest_file, s3_key_path_manifest_file + cl_manifest_file) # Print S3 URL to manifest file, print ('S3 URL Path to manifest file. ') print('\033[1m s3://' + s3_bucket + '/' + s3_key_path_manifest_file + cl_manifest_file + '\033[0m') # Display aws s3 sync command. print ('\nAWS CLI s3 sync command to upload your images to S3 bucket. ') print ('\033[1m aws s3 sync ' + local_images_path + ' ' + s3_path + '\033[0m') ``` 1. Führen Sie den Code aus. 1. Notieren Sie den `s3 sync`-Befehl in der Programmausgabe. Sie benötigen ihn im nächsten Schritt. 1. Führen Sie über die Eingabeaufforderung den folgenden `s3 sync`-Befehl aus. Ihre Bilder werden zu dem S3-Bucket hochgeladen. Wenn der Befehl beim Hochladen fehlschlägt, führen Sie ihn erneut aus, bis Ihre lokalen Bilder mit dem S3-Bucket synchronisiert sind. 1. Notieren Sie sich in der Programmausgabe den S3-URL-Pfad zur Manifestdatei. Sie benötigen ihn im nächsten Schritt. 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 im **Manifestdatei-Speicherort** die Amazon S3-URL ein, die Sie sich im vorherigen Schritt notiert haben. 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. # Transformation von SageMaker AI Ground Truth-Manifestdateien mit mehreren Labels In diesem Thema erfahren Sie, wie Sie eine Amazon SageMaker AI Ground Truth-Manifestdatei mit mehreren Labels in eine Manifestdatei im Amazon Rekognition Custom Labels-Format umwandeln. SageMaker AI Ground Truth Truth-Manifestdateien für Aufträge mit mehreren Labels sind anders formatiert als Manifestdateien im Amazon Rekognition Custom Labels-Format. Bei der Klassifizierung mit mehreren Labels wird ein Bild in eine Gruppe von Klassen eingeteilt, kann aber gleichzeitig mehreren Klassen angehören. In diesem Fall kann das Bild möglicherweise mehrere Labels haben, z. B. *Fußball* und *Ball*. Informationen zu SageMaker KI-Ground-Truth-Aufträgen mit mehreren Labels finden Sie unter [Bildklassifizierung (mehrere Labels](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-image-classification-multilabel.html)). Informationen zu Amazon Rekognition Custom Labels-Manifestdateien im Format mit mehreren Labels finden Sie unter [Hinzufügen mehrerer Labels auf Bildebene zu einem Bild](md-create-manifest-file-classification.md#md-dataset-purpose-classification-multiple-labels). ## Die Manifestdatei für einen SageMaker AI Ground Truth Job abrufen Das folgende Verfahren zeigt Ihnen, wie Sie die Ausgabe-Manifestdatei (`output.manifest`) für einen Amazon SageMaker AI Ground Truth Job abrufen. Sie verwenden `output.manifest` als Eingabe für das nächste Verfahren. **So laden Sie eine SageMaker AI Ground Truth Job-Manifest-Datei herunter** 1. Öffnen Sie die [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/). 1. Wählen Sie im Navigationsbereich **Ground Truth** und dann **Labeling-Jobs** aus. 1. Wählen Sie den Labeling-Job, der die Manifestdatei enthält, die Sie verwenden möchten. 1. Wählen Sie auf der Detailseite den Link unter **Speicherort des Ausgabe-Datensatzes** aus. Die Amazon S3-Konsole wird am Speicherort des Datensatzes geöffnet. 1. Wählen Sie `Manifests`, `output` und anschließend `output.manifest` aus. 1. Um die Manifestdatei herunterzuladen, wählen Sie **Objektanmerkungen** und dann **Herunterladen** aus. ## Transformation einer SageMaker AI-Manifestdatei mit mehreren Bezeichnungen Das folgende Verfahren erstellt eine Amazon Rekognition Custom Labels-Manifestdatei im Multi-Label-Format aus einer vorhandenen AI-Manifestdatei im Multi-Label-Format SageMaker . GroundTruth **Anmerkung** Um den Code auszuführen, benötigen Sie Python Version 3 oder höher. **Um eine AI-Manifestdatei mit mehreren Bezeichnungen zu transformieren SageMaker** 1. Führen Sie den folgenden Python-Code aus. Geben Sie den Namen der Manifestdatei, die Sie in [Die Manifestdatei für einen SageMaker AI Ground Truth Job abrufen](#md-get-gt-manifest) als Befehlszeilenargument erstellt haben, an. ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Purpose Shows how to create and Amazon Rekognition Custom Labels format manifest file from an Amazon SageMaker Ground Truth Image Classification (Multi-label) format manifest file. """ import json import logging import argparse import os.path logger = logging.getLogger(__name__) def create_manifest_file(ground_truth_manifest_file): """ Creates an Amazon Rekognition Custom Labels format manifest file from an Amazon SageMaker Ground Truth Image Classification (Multi-label) format manifest file. :param: ground_truth_manifest_file: The name of the Ground Truth manifest file, including the relative path. :return: The name of the new Custom Labels manifest file. """ logger.info('Creating manifest file from %s', ground_truth_manifest_file) new_manifest_file = f'custom_labels_{os.path.basename(ground_truth_manifest_file)}' # Read the SageMaker Ground Truth manifest file into memory. with open(ground_truth_manifest_file) as gt_file: lines = gt_file.readlines() #Iterate through the lines one at a time to generate the #new lines for the Custom Labels manifest file. with open(new_manifest_file, 'w') as the_new_file: for line in lines: #job_name - The of the Amazon Sagemaker Ground Truth job. job_name = '' # Load in the old json item from the Ground Truth manifest file old_json = json.loads(line) # Get the job name keys = old_json.keys() for key in keys: if 'source-ref' not in key and '-metadata' not in key: job_name = key new_json = {} # Set the location of the image new_json['source-ref'] = old_json['source-ref'] # Temporarily store the list of labels labels = old_json[job_name] # Iterate through the labels and reformat to Custom Labels format for index, label in enumerate(labels): new_json[f'{job_name}{index}'] = index metadata = {} metadata['class-name'] = old_json[f'{job_name}-metadata']['class-map'][str(label)] metadata['confidence'] = old_json[f'{job_name}-metadata']['confidence-map'][str(label)] metadata['type'] = 'groundtruth/image-classification' metadata['job-name'] = old_json[f'{job_name}-metadata']['job-name'] metadata['human-annotated'] = old_json[f'{job_name}-metadata']['human-annotated'] metadata['creation-date'] = old_json[f'{job_name}-metadata']['creation-date'] # Add the metadata to new json line new_json[f'{job_name}{index}-metadata'] = metadata # Write the current line to the json file the_new_file.write(json.dumps(new_json)) the_new_file.write('\n') logger.info('Created %s', new_manifest_file) return new_manifest_file def add_arguments(parser): """ Adds command line arguments to the parser. :param parser: The command line parser. """ parser.add_argument( "manifest_file", help="The Amazon SageMaker Ground Truth manifest file" "that you want to use." ) 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() # Create the manifest file manifest_file = create_manifest_file(args.manifest_file) print(f'Manifest file created: {manifest_file}') except FileNotFoundError as err: logger.exception('File not found: %s', err) print(f'File not found: {err}. Check your manifest file.') if __name__ == "__main__": main() ``` 1. Notieren Sie sich den Namen der neuen Manifestdatei, die das Skript anzeigt. Sie werden ihn im nächsten Schritt verwenden. 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. # Erstellen einer Manifestdatei aus einer CSV-Datei 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.