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.
# 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).