Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Conversion d’autres formats de jeu de données en fichier manifeste Vous pouvez utiliser les informations suivantes pour créer des fichiers manifestes au format Amazon SageMaker AI à partir de différents formats de jeux de données sources. Après avoir créé le fichier manifeste, utilisez-le pour créer un jeu de données. Pour de plus amples informations, veuillez consulter [Utilisation d'un fichier manifeste pour importer des images](md-create-dataset-ground-truth.md). **Topics** + [Transformation d'un ensemble de données COCO en un format de fichier manifeste](md-transform-coco.md) + [Transformation des fichiers manifestes SageMaker AI Ground Truth à étiquettes multiples](md-gt-cl-transform.md) + [Création d’un fichier manifeste à partir d’un fichier CSV](ex-csv-manifest.md) # Transformation d'un ensemble de données COCO en un format de fichier manifeste [COCO](http://cocodataset.org/#home) est un format permettant de spécifier des jeux de données de détection, de segmentation et de sous-titrage des objets à grande échelle. Cet [exemple](md-coco-transform-example.md) Python vous montre comment transformer un jeu de données au format de détection d’objets COCO en un [fichier manifeste Étiquettes personnalisées Amazon Rekognition au format cadre de délimitation](md-create-manifest-file-object-detection.md). Cette section inclut également des informations que vous pouvez utiliser pour écrire votre propre code. Un fichier JSON au format COCO se compose de cinq sections fournissant des informations pour un *jeu de données complet*. Pour plus d’informations, consultez [Le format du jeu de données COCO](md-coco-overview.md). + `info` : informations générales sur le jeu de données. + `licenses ` : informations de licence pour les images du jeu de données. + [`images`](md-coco-overview.md#md-coco-images) : liste des images du jeu de données. + [`annotations`](md-coco-overview.md#md-coco-annotations) : liste d’annotations (y compris les cadres de délimitation) présentes dans toutes les images du jeu de données. + [`categories`](md-coco-overview.md#md-coco-categories) : liste des catégories d’étiquettes. Vous aurez besoin d’informations provenant des listes `images`, `annotations` et `categories` pour créer un fichier manifeste Étiquettes personnalisées Amazon Rekognition. Un fichier manifeste Étiquettes personnalisées Amazon Rekognition est au format de lignes JSON. Chaque ligne contient les informations relatives aux cadres de délimitation et aux étiquettes d’un ou de plusieurs objets *dans une image*. Pour plus d’informations, consultez [Localisation d’objets dans les fichiers manifestes](md-create-manifest-file-object-detection.md). ## Mappage d’objets COCO avec une ligne JSON Étiquettes personnalisées Pour transformer un jeu de données au format COCO, mappez le jeu de données COCO avec un fichier manifeste Étiquettes personnalisées Amazon Rekognition pour la localisation d’objets. Pour de plus amples informations, veuillez consulter [Localisation d’objets dans les fichiers manifestes](md-create-manifest-file-object-detection.md). Pour créer une ligne JSON pour chaque image, le fichier manifeste doit mapper le jeu de données `image` COCO et le champ `category` d'objet IDs. `annotation` Voici un exemple de fichier manifeste COCO. Pour plus d’informations, consultez [Le format du jeu de données COCO](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"} ] } ``` Le schéma suivant montre comment les listes de jeux de données COCO pour un *jeu de données* sont mappées avec les lignes JSON d’Étiquettes personnalisées Amazon Rekognition pour une *image*. Chaque ligne JSON d'une image possède une référence source, un champ de métadonnées de tâche et un champ de métadonnées de tâche. Les couleurs qui sont les mêmes indiquent des informations relatives à une seule image. Notez que dans le manifeste, une image individuelle peut comporter plusieurs annotations et métadonnées/catégories. ![\[Schéma montrant la structure de Coco Manifest, avec les images, les annotations et les catégories qu'il contient.\]](http://docs.aws.amazon.com/fr_fr/rekognition/latest/customlabels-dg/images/coco-transform.png) **Pour obtenir les objets COCO pour une seule ligne JSON** 1. Pour chaque image de la liste d’images, récupérez l’annotation dans la liste d’annotations où la valeur du champ d’annotation `image_id` correspond à celle du champ `id` de l’image. 1. Pour chaque annotation ayant une correspondance dans l’étape 1, parcourez la liste `categories` et récupérez chaque `category` où la valeur du champ `category` `id` correspond au champ `category_id` de l’objet `annotation`. 1. Créez une ligne JSON pour l’image à l’aide des objets `image`, `annotation` et `category` associés. Pour mapper les champs, consultez [Mappage de champs d’objet COCO avec des champs d’objet de ligne JSON Étiquettes personnalisées](#md-mapping-fields-coco). 1. Répétez les étapes 1 à 3 jusqu’à ce que vous ayez créé des lignes JSON pour chaque objet `image` de la liste `images`. Pour obtenir un exemple de code, consultez [Conversion d’un jeu de données COCO](md-coco-transform-example.md). ## Mappage de champs d’objet COCO avec des champs d’objet de ligne JSON Étiquettes personnalisées Après avoir identifié les objets COCO pour une ligne Étiquettes personnalisées Amazon Rekognition, vous devez mapper les champs d’objets COCO avec les champs d’objet de ligne JSON Étiquettes personnalisées Amazon Rekognition respectifs. L’exemple suivant de ligne JSON Étiquettes personnalisées Amazon Rekognition mappe une image (`id`=`000000245915`) avec l’exemple JSON COCO précédent. Notez les informations suivantes. + `source-ref` correspond à l’emplacement de l’image dans un compartiment Amazon S3. Si vos images COCO ne sont pas stockées dans un compartiment Amazon S3, vous devez les y transférer. + La liste `annotations` contient un objet `annotation` pour chaque objet de l’image. Un objet `annotation` comprend des informations relatives à un cadre de délimitation (`top`, `left`, `width`, `height`) et un identifiant d’étiquette (`class_id`). + L’identifiant d’étiquette (`class_id`) correspond à la liste `class-map` figurant dans les métadonnées. Il répertorie les étiquettes utilisées sur l’image. ``` { "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" } } ``` Utilisez les informations suivantes pour mapper les champs du fichier manifeste Étiquettes personnalisées Amazon Rekognition avec les champs JSON du jeu de données COCO. ### source-ref URL au format S3 pour l’emplacement de l’image. L’image doit être stockée dans un compartiment S3. Pour plus d’informations, consultez [source-ref](md-create-manifest-file-object-detection.md#cd-manifest-source-ref). Si le champ COCO `coco_url` pointe vers l’emplacement d’un compartiment S3, vous pouvez utiliser la valeur de `coco_url` pour la valeur de `source-ref`. Vous pouvez également mapper `source-ref` avec le champ (COCO) `file_name` et ajouter dans le code de transformation le chemin S3 requis vers l’endroit où l’image est stockée. ### *bounding-box* Nom d’attribut d’étiquette de votre choix. Pour plus d’informations, consultez [*bounding-box*](md-create-manifest-file-object-detection.md#md-manifest-source-bounding-box). #### image\$1size Taille de l’image, en pixels. Correspond à un objet `image` dans la liste des [images](md-coco-overview.md#md-coco-images). + `height`-> `image.height` + `width`-> `image.width` + `depth`-> Pas utilisé par Étiquettes personnalisées Amazon Rekognition, mais une valeur doit être fournie. #### annotations Liste d’objets `annotation`. Il y a une `annotation` pour chaque objet de l’image. #### annotation Contient les informations relatives au cadre de délimitation pour une instance d’un objet sur l’image. + `class_id` -> mappage d’ID numérique avec la liste `class-map` d’Étiquettes personnalisées. + `top` -> `bbox[1]` + `left` -> `bbox[0]` + `width` -> `bbox[2]` + `height` -> `bbox[3]` ### *bounding-box*-métadonnées Métadonnées pour l’attribut d’étiquette. Inclut les étiquettes et les identifiants d’étiquettes. Pour plus d’informations, consultez [*bounding-box*-métadonnées](md-create-manifest-file-object-detection.md#md-manifest-source-bounding-box-metadata). #### Objets Tableau des objets de l’image. Correspond à la liste `annotations` par index. ##### Objet + `confidence`-> Pas utilisé par Étiquettes personnalisées Amazon Rekognition, mais une valeur (1) doit être fournie. #### class-map Mappage des étiquettes (classes) qui s’appliquent aux objets détectés dans l’image. Correspond aux objets de catégorie dans la liste des [catégories](md-coco-overview.md#md-coco-categories). + `id` -> `category.id` + `id value` -> `category.name` #### type Doit être `groundtruth/object-detection` #### human-annotated Spécifiez `yes` ou `no`. Pour plus d’informations, consultez [*bounding-box*-métadonnées](md-create-manifest-file-object-detection.md#md-manifest-source-bounding-box-metadata). #### creation-date -> [image](md-coco-overview.md#md-coco-images).date\$1captured Date et heure de création de l’image. Correspond au champ [image](md-coco-overview.md#md-coco-images).date\$1captured d’une image dans la liste des images COCO. Étiquettes personnalisées Amazon Rekognition attend du format `creation-date` qu’il correspond à *Y-M-DTH:M:S*. #### job-name Nom de tâche de votre choix. # Le format du jeu de données COCO Un jeu de données COCO se compose de cinq sections d’informations qui fournissent des informations pour le jeu de données complet. Le format d’un jeu de données de détection d’objets COCO est documenté dans la section [Format de données COCO](http://cocodataset.org/#format-data). + info : informations générales sur le jeu de données. + licenses : informations de licence pour les images du jeu de données. + [images](#md-coco-images) : liste des images du jeu de données. + [annotations](#md-coco-annotations) : liste d’annotations (y compris les cadres de délimitation) présentes dans toutes les images du jeu de données. + [categories](#md-coco-categories) : liste des catégories d’étiquettes. Pour créer un manifeste Étiquettes personnalisées, utilisez les listes `images`, `annotations` et `categories` du fichier manifeste COCO. Les autres sections (`info`, `licences`) ne sont pas obligatoires. Voici un exemple de fichier manifeste COCO. ``` { "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 d’images Les images référencées par un jeu de données COCO sont répertoriées dans le tableau d’images. Chaque objet image contient des informations sur l’image, telles que le nom du fichier image. Dans l’exemple d’objet image ci-dessous, notez les informations suivantes et les champs obligatoires pour créer un fichier manifeste Étiquettes personnalisées Amazon Rekognition. + `id` : (obligatoire) identifiant unique de l’image. Le champ `id` correspond au champ `id` du tableau d’annotations (où les informations relatives aux cadres de délimitation sont stockées). + `license` : (facultatif) correspond au tableau de licences. + `coco_url` : (facultatif) emplacement de l’image. + `flickr_url` : (facultatif) emplacement de l’image sur Flickr. + `width` : (obligatoire) largeur de l’image. + `height` : (obligatoire) hauteur de l’image. + `file_name` : (obligatoire) nom du fichier image. Dans cet exemple, `file_name` et `id` correspondent, mais cela n’est pas obligatoire pour les jeux de données COCO. + `date_captured` : (obligatoire) date et heure de capture de l’image. ``` { "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 des annotations (cadres de délimitation) Les informations relatives aux cadres de délimitation pour tous les objets de toutes les images sont stockées dans la liste des annotations. Un seul objet d’annotation contient les informations relatives au cadre de délimitation correspondant à un seul objet et l’étiquette de l’objet sur une image. Il existe un objet d’annotation pour chaque instance d’un objet sur une image. Dans l’exemple ci-dessous, notez les informations suivantes et les champs obligatoires pour créer un fichier manifeste Étiquettes personnalisées Amazon Rekognition. + `id` : (facultatif) identifiant de l’annotation. + `image_id` : (obligatoire) correspond à l’image `id` dans le tableau d’images. + `category_id` : (obligatoire) identifiant de l’étiquette qui identifie l’objet dans un cadre de délimitation. Il correspond au champ `id` du tableau des catégories. + `iscrowd` : (facultatif) spécifie si l’image contient une foule d’objets. + `segmentation` : (facultatif) informations de segmentation pour les objets d’une image. Étiquettes personnalisées Amazon Rekognition ne prend pas en charge la segmentation. + `area` : (facultatif) zone de l’annotation. + `bbox` : (obligatoire) contient les coordonnées, en pixels, d’un cadre de délimitation autour d’un objet sur l’image. ``` { "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 des catégories Les informations relatives aux étiquettes sont stockées dans le tableau des catégories. Dans l’exemple d’objet de catégorie ci-dessous, notez les informations suivantes et les champs obligatoires pour créer un fichier manifeste Étiquettes personnalisées Amazon Rekognition. + `supercategory` : (facultatif) catégorie parent d’une étiquette. + `id` : (obligatoire) identifiant de l’étiquette. Le champ `id` correspond au champ `category_id` d’un objet `annotation`. Dans l’exemple suivant, l’identifiant d’un appareil echo dot est 2. + `name` : (obligatoire) nom de l’étiquette. ``` {"supercategory": "speaker","id": 2,"name": "echo dot"} ``` # Conversion d’un jeu de données COCO Utilisez l’exemple Python suivant pour transformer les informations du cadre de délimitation d’un jeu de données au format COCO en un fichier manifeste Étiquettes personnalisées Amazon Rekognition. Le code charge le fichier manifeste créé dans votre compartiment Amazon S3. Le code fournit également une commande AWS CLI que vous pouvez utiliser pour charger vos images. **Pour convertir un jeu de données COCO (kit SDK)** 1. Si vous ne l’avez pas déjà fait : 1. Vérifiez que vous disposez des autorisations `AmazonS3FullAccess`. Pour de plus amples informations, veuillez consulter [Configuration des autorisations du kit SDK](su-sdk-permissions.md). 1. Installez et configurez le AWS CLI et le AWS SDKs. Pour de plus amples informations, veuillez consulter [Étape 4 : configurer le AWS CLI et AWS SDKs](su-awscli-sdk.md). 1. Utilisez le code Python suivant pour convertir un jeu de données COCO. Définissez les valeurs suivantes. + `s3_bucket` : nom du compartiment S3 dans lequel vous souhaitez stocker les images et le fichier manifeste Étiquettes personnalisées Amazon Rekognition. + `s3_key_path_images` : chemin d’accès vers l’endroit où vous souhaitez placer les images dans le compartiment S3 (`s3_bucket`). + `s3_key_path_manifest_file` : chemin d’accès vers l’endroit où vous souhaitez placer le fichier manifeste Étiquettes personnalisées dans le compartiment S3 (`s3_bucket`). + `local_path` : chemin local vers lequel l’exemple ouvre le jeu de données COCO en entrée et enregistre également le nouveau fichier manifeste Étiquettes personnalisées. + `local_images_path` : chemin local vers les images que vous souhaitez utiliser pour l’entraînement. + `coco_manifest` : nom de fichier du jeu de données COCO en entrée. + `cl_manifest_file` : nom du fichier manifeste créé par l’exemple. Ce fichier est enregistré à l’emplacement indiqué par `local_path`. Par convention, il possède l’extension `.manifest`, mais cela n’est pas obligatoire. + `job_name` : nom de la tâche Étiquettes personnalisées. ``` 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. Exécutez le code. 1. Dans la sortie du programme, notez la commande `s3 sync`. Vous en aurez besoin à l’étape suivante. 1. À partir d’une invite de commande, exécutez la commande `s3 sync`. Vos images sont importées dans le compartiment S3. Si la commande échoue pendant le chargement, exécutez-la à nouveau jusqu’à ce que les images locales soient synchronisées avec le compartiment S3. 1. Dans la sortie du programme, notez le chemin de l’URL S3 vers le fichier manifeste. Vous en aurez besoin à l’étape suivante. 1. Suivez les instructions sous [Création d'un ensemble de données à l'aide d'un fichier manifeste SageMaker AI Ground Truth (console)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console) pour créer un jeu de données avec le fichier manifeste chargé. Pour l’étape 8, dans **Emplacement du fichier .manifest**, entrez l’URL Amazon S3 que vous avez notée à l’étape précédente. Si vous utilisez le kit AWS SDK, effectuez les actions indiquées dans [Création d'un ensemble de données à l'aide d'un fichier manifeste (SDK) SageMaker AI Ground Truth](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk). # Transformation des fichiers manifestes SageMaker AI Ground Truth à étiquettes multiples Cette rubrique explique comment transformer un fichier manifeste Amazon SageMaker AI Ground Truth à étiquettes multiples en un fichier manifeste au format Amazon Rekognition Custom Labels. SageMaker Les fichiers manifestes AI Ground Truth pour les tâches à étiquettes multiples sont formatés différemment des fichiers manifestes au format Amazon Rekognition Custom Labels. La classification à plusieurs étiquettes a lieu lorsqu’une image est classée dans un ensemble de classes, mais qu’elle peut appartenir à plusieurs classes à la fois. Dans ce cas, l’image peut potentiellement comporter plusieurs étiquettes, telles que *football* et *ballon*. Pour plus d'informations sur les tâches SageMaker AI Ground Truth à étiquettes multiples, consultez la section [Classification d'images (étiquettes multiples)](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-image-classification-multilabel.html). Pour plus d’informations sur les fichiers manifestes Étiquettes personnalisées Amazon Rekognition à plusieurs étiquettes, consultez [Ajout de plusieurs étiquettes au niveau de l’image à une image](md-create-manifest-file-classification.md#md-dataset-purpose-classification-multiple-labels). ## Obtenir le fichier manifeste pour une tâche d' SageMaker AI Ground Truth La procédure suivante explique comment obtenir le fichier manifeste de sortie (`output.manifest`) pour une tâche Amazon SageMaker AI Ground Truth. Utilisez `output.manifest` comme entrée pour la procédure suivante. **Pour télécharger un fichier manifeste de travail d' SageMaker AI Ground Truth** 1. Ouvrez la [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/). 1. Dans le volet de navigation, choisissez **Ground Truth**, puis **Étiquetage des tâches**. 1. Choisissez la tâche d’étiquetage qui contient le fichier manifeste que vous souhaitez utiliser. 1. Sur la page de détails, cliquez sur le lien sous **Emplacement de l’ensemble de données de sortie**. La console Amazon S3 s’ouvre à l’emplacement du jeu de données. 1. Choisissez `Manifests`, `output` puis `output.manifest`. 1. Pour télécharger le fichier manifeste, choisissez **Actions d’objet**, puis **Télécharger**. ## Transformation d'un fichier manifeste d' SageMaker IA à étiquettes multiples La procédure suivante crée un fichier manifeste Amazon Rekognition Custom Labels au format multi-étiquettes à partir d'un fichier manifeste AI au format multi-étiquettes existant. SageMaker GroundTruth **Note** Pour exécuter le code, vous avez besoin de la version 3 de Python ou d’une version supérieure. **Pour transformer un fichier manifeste SageMaker AI à étiquettes multiples** 1. Exécutez le code Python suivant. Indiquez le nom du fichier manifeste que vous avez créé dans [Obtenir le fichier manifeste pour une tâche d' SageMaker AI Ground Truth](#md-get-gt-manifest) en tant qu’argument de ligne de commande. ``` # 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. Notez le nom du nouveau fichier manifeste affiché par le script. Vous l’utiliserez à l’étape suivante. 1. [Chargez les fichiers manifestes](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) dans le compartiment Amazon S3 que vous souhaitez utiliser pour stocker ce type de fichier. **Note** Assurez-vous qu’Étiquettes personnalisées Amazon Rekognition a accès au compartiment Amazon S3 référencé dans le champ `source-ref` des lignes JSON du fichier manifeste. Pour plus d’informations, consultez [Accès à des compartiments Amazon S3 externes](su-console-policy.md#su-external-buckets). Si la tâche Ground Truth stocke des images dans le compartiment de la console Étiquettes personnalisées Amazon Rekognition, vous n’avez pas besoin d’ajouter d’autorisations. 1. Suivez les instructions sous [Création d'un ensemble de données à l'aide d'un fichier manifeste SageMaker AI Ground Truth (console)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console) pour créer un jeu de données avec le fichier manifeste chargé. Pour l’étape 8, dans **Emplacement du fichier .manifest**, entrez l’URL Amazon S3 correspondant à l’emplacement du fichier manifeste. Si vous utilisez le kit AWS SDK, effectuez les actions indiquées dans [Création d'un ensemble de données à l'aide d'un fichier manifeste (SDK) SageMaker AI Ground Truth](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk). # Création d’un fichier manifeste à partir d’un fichier CSV Cet exemple de script Python simplifie la création d’un fichier manifeste en utilisant un fichier CSV pour étiqueter les images. C’est vous qui créez le fichier CSV. Le fichier manifeste convient à la [classification d’images à plusieurs étiquettes](getting-started.md#gs-multi-label-image-classification-example) ou [Classification des images à plusieurs étiquettes](getting-started.md#gs-multi-label-image-classification-example). Pour plus d’informations, consultez [Recherche d’objets, de scènes et de concepts](understanding-custom-labels.md#tm-classification). **Note** Ce script ne crée pas de fichier manifeste adapté à la [recherche des emplacements d’objets](understanding-custom-labels.md#tm-object-localization) ni à la [recherche des marques](understanding-custom-labels.md#tm-brand-detection-localization). Un fichier manifeste décrit les images utilisées pour entraîner un modèle (par exemple, les emplacements des images et les étiquettes attribuées aux images). Un fichier manifeste est composé d’une ou plusieurs lignes JSON. Chaque ligne JSON décrit une seule image. Pour plus d’informations, consultez [Importation d'étiquettes au niveau de l'image dans des fichiers manifestes](md-create-manifest-file-classification.md). Un fichier CSV 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](https://en.wikipedia.org/wiki/Comma-separated_values). Pour ce script, chaque ligne du fichier CSV représente une image unique et correspond à une ligne JSON dans le fichier manifeste. Pour créer un fichier CSV pour un fichier manifeste prenant en charge la [classification d’images à plusieurs étiquettes](getting-started.md#gs-multi-label-image-classification-example), vous devez ajouter une ou plusieurs étiquettes au niveau de l’image à chaque ligne. Pour créer un fichier manifeste adapté à la [Classification d’images](getting-started.md#gs-image-classification-example), vous devez ajouter une seule étiquette au niveau de l’image à chaque ligne. Par exemple, le fichier CSV suivant décrit les images du projet de *mise en route* [Classification des images à plusieurs étiquettes](getting-started.md#gs-multi-label-image-classification-example) (Flowers). ``` 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 ``` Le script génère des lignes JSON pour chaque ligne. Par exemple, voici la ligne JSON pour la première ligne (`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"}} ``` Dans l’exemple de fichier CSV, le chemin Amazon S3 vers l’image n’est pas présent. Si le fichier CSV n’inclut pas le chemin Amazon S3 des images, utilisez l’argument de ligne de commande `--s3_path` pour spécifier cette information pour l’image. Le script enregistre la première entrée pour chaque image dans un fichier image CSV dédupliqué. Le fichier image CSV dédupliqué contient une seule instance de chaque image trouvée dans le fichier CSV d’entrée. Les autres occurrences d’une image dans le fichier CSV d’entrée sont enregistrées dans un fichier image CSV dupliqué. Si le script détecte des images dupliquées, examinez le fichier image CSV dupliqué et mettez à jour le fichier image CSV dédupliqué si nécessaire. Réexécutez le script avec le fichier dédupliqué. Si aucun doublon n'est détecté dans le fichier CSV d'entrée, le script supprime le fichier image CSV dédupliqué et l'image dupliquée CSVfile, car ils sont vides. Dans cette procédure, c’est vous qui créez le fichier CSV et qui exécutez le script Python pour créer le fichier manifeste. **Pour créer un fichier manifeste à partir d’un fichier CSV** 1. Créez un fichier CSV avec les champs suivants dans chaque ligne (une ligne par image). N’ajoutez pas de ligne d’en-tête au fichier CSV. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/rekognition/latest/customlabels-dg/ex-csv-manifest.html) Par exemple : `camellia1.jpg,camellia,with_leaves` ou `s3://my-bucket/flowers/train/camellia1.jpg,camellia,with_leaves` 1. Enregistrez le fichier CSV. 1. Exécutez le script Python suivant. Fournissez les arguments suivants : + `csv_file` : fichier CSV que vous avez créé à l’étape 1. + `manifest_file` : nom du fichier manifeste que vous souhaitez créer. + (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 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. Si vous prévoyez d’utiliser un jeu de données de test, répétez les étapes 1 à 3 afin de créer un fichier manifeste pour le jeu de données de test. 1. Si nécessaire, copiez les images dans le chemin du compartiment Amazon S3 que vous avez spécifié dans la colonne 1 du fichier CSV (ou dans la ligne de commande `--s3_path`). Vous pouvez utiliser la commande S3 AWS suivante : ``` aws s3 cp --recursive your-local-folder s3://your-target-S3-location ``` 1. [Chargez les fichiers manifestes](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) dans le compartiment Amazon S3 que vous souhaitez utiliser pour stocker ce type de fichier. **Note** Assurez-vous qu’Étiquettes personnalisées Amazon Rekognition a accès au compartiment Amazon S3 référencé dans le champ `source-ref` des lignes JSON du fichier manifeste. Pour plus d’informations, consultez [Accès à des compartiments Amazon S3 externes](su-console-policy.md#su-external-buckets). Si la tâche Ground Truth stocke des images dans le compartiment de la console Étiquettes personnalisées Amazon Rekognition, vous n’avez pas besoin d’ajouter d’autorisations. 1. Suivez les instructions sous [Création d'un ensemble de données à l'aide d'un fichier manifeste SageMaker AI Ground Truth (console)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console) pour créer un jeu de données avec le fichier manifeste chargé. Pour l’étape 8, dans **Emplacement du fichier .manifest**, entrez l’URL Amazon S3 correspondant à l’emplacement du fichier manifeste. Si vous utilisez le kit AWS SDK, effectuez les actions indiquées dans [Création d'un ensemble de données à l'aide d'un fichier manifeste (SDK) SageMaker AI Ground Truth](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk).