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.
# Utilisation d'un fichier manifeste pour importer des images
Vous pouvez créer un ensemble de données à l'aide d'un fichier manifeste au format Amazon SageMaker AI Ground Truth. Vous pouvez utiliser le fichier manifeste d'une tâche Amazon SageMaker AI Ground Truth. Si vos images et vos étiquettes ne sont pas au format d'un fichier manifeste SageMaker AI Ground Truth, vous pouvez créer un fichier manifeste au format SageMaker AI et l'utiliser pour importer vos images étiquetées.
L'`CreateDataset`opération est mise à jour pour vous permettre de spécifier éventuellement des balises lors de la création d'un nouvel ensemble de données. Les balises sont des paires clé-valeur que vous pouvez utiliser pour classer et gérer vos ressources.
**Topics**
+ [Création d'un ensemble de données à l'aide d'un fichier manifeste SageMaker AI Ground Truth (console)](#md-create-dataset-ground-truth-console)
+ [Création d'un ensemble de données à l'aide d'un fichier manifeste (SDK) SageMaker AI Ground Truth](#md-create-dataset-ground-truth-sdk)
+ [Créer une demande de jeu de données](#create-dataset-ground-truth-request)
+ [Étiqueter des images avec une tâche Amazon SageMaker AI Ground Truth](md-create-dataset-ground-truth-job.md)
+ [Création d’un fichier manifeste](md-create-manifest-file.md)
+ [Importation d'étiquettes au niveau de l'image dans des fichiers manifestes](md-create-manifest-file-classification.md)
+ [Localisation d’objets dans les fichiers manifestes](md-create-manifest-file-object-detection.md)
+ [Règles de validation des fichiers manifestes](md-create-manifest-file-validation-rules.md)
+ [Conversion d’autres formats de jeu de données en fichier manifeste](md-converting-to-sm-format.md)
## Création d'un ensemble de données à l'aide d'un fichier manifeste SageMaker AI Ground Truth (console)
La procédure suivante explique comment créer un ensemble de données à l'aide d'un fichier manifeste au format SageMaker AI Ground Truth.
1. Pour créer un fichier manifeste pour le jeu de données d’entraînement, effectuez l’une des actions suivantes :
+ Créez un fichier manifeste avec un SageMaker AI GroundTruth Job en suivant les instructions de[Étiqueter des images avec une tâche Amazon SageMaker AI Ground Truth](md-create-dataset-ground-truth-job.md).
+ Créez votre propre fichier manifeste en suivant les instructions sous [Création d’un fichier manifeste](md-create-manifest-file.md).
Si vous souhaitez créer un jeu de données de test, répétez l’étape 1.
1. Ouvrez la console Amazon Rekognition à l'adresse. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Choisissez **Utiliser Custom Labels**.
1. Choisissez **Démarrer**.
1. Dans le volet de navigation de gauche, choisissez **Projets**.
1. Sur la page **Projets**, choisissez le projet auquel vous souhaitez ajouter un jeu de données. La page de détails de ce projet s’affiche.
1. Choisissez **Créer un jeu de données**. La page **Créer un jeu de données** s’affiche.
1. Dans **Démarrage de la configuration**, choisissez **Démarrer avec un seul jeu de données** ou **Démarrer avec un jeu de données d’entraînement**. Pour créer un modèle de meilleure qualité, nous vous recommandons de commencer par un jeu de données d’entraînement et un jeu de données de test distincts.
------
#### [ Single dataset ]
1. Dans la section des **détails du jeu de données d'entraînement**, choisissez **Importer des images étiquetées par SageMaker Ground Truth**.
1. Dans **Emplacement du fichier .manifest**, entrez l’emplacement du fichier manifeste que vous avez créé à l’étape 1.
1. Choisissez **Créer un jeu de données**. La page des jeux de données de votre projet s’ouvre.
------
#### [ Separate training and test datasets ]
1. Dans la section des **détails du jeu de données d'entraînement**, choisissez **Importer des images étiquetées par SageMaker Ground Truth**.
1. Dans **Emplacement du fichier .manifest**, entrez l’emplacement du fichier manifeste que vous avez créé à l’étape 1 pour le jeu de données d’entraînement.
1. Dans la section **Détails du jeu de données de test**, choisissez **Importer des images étiquetées par SageMaker Ground Truth**.
**Note**
Le jeu de données d’entraînement et le jeu de données de test peuvent avoir différentes sources d’images.
1. Dans **Emplacement du fichier .manifest**, entrez l’emplacement du fichier manifeste que vous avez créé à l’étape 1 pour le jeu de données de test.
1. Choisissez **Créer des jeux de données**. La page des jeux de données de votre projet s’ouvre.
------
1. Si vous devez ajouter ou modifier des étiquettes, effectuez les actions indiquées dans [Étiquetage des images](md-labeling-images.md).
1. Suivez les étapes décrites dans [Entraînement d’un modèle (console)](training-model.md#tm-console) pour entraîner le modèle.
## Création d'un ensemble de données à l'aide d'un fichier manifeste (SDK) SageMaker AI Ground Truth
La procédure suivante explique comment créer des ensembles de données d'entraînement ou de test à partir d'un fichier manifeste à l'aide de l'[CreateDataset](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateDataset)API.
Vous pouvez utiliser un fichier manifeste existant, tel que le résultat d'une [tâche SageMaker AI Ground Truth](md-create-dataset-ground-truth-job.md), ou créer votre propre [fichier manifeste](md-create-manifest-file.md).
1. Si ce n'est pas déjà fait, installez et configurez le AWS CLI et le AWS SDKs. Pour de plus amples informations, veuillez consulter [Étape 4 : Configurez le AWS CLI and AWS Kits SDK](su-awscli-sdk.md).
1. Pour créer un fichier manifeste pour le jeu de données d’entraînement, effectuez l’une des actions suivantes :
+ Créez un fichier manifeste avec un SageMaker AI GroundTruth Job en suivant les instructions de[Étiqueter des images avec une tâche Amazon SageMaker AI Ground Truth](md-create-dataset-ground-truth-job.md).
+ Créez votre propre fichier manifeste en suivant les instructions sous [Création d’un fichier manifeste](md-create-manifest-file.md).
Si vous souhaitez créer un jeu de données de test, répétez l’étape 2.
1. Utilisez l’exemple de code suivant pour créer le jeu de données d’entraînement et de test.
------
#### [ AWS CLI ]
Utilisez le code suivant pour créer un jeu de données. Remplacez les éléments suivants :
+ `project_arn` : ARN du projet que vous souhaitez ajouter au jeu de données de test.
+ `type` : type de jeu de données que vous souhaitez créer (TRAIN pour « entraînement » ou TEST).
+ `bucket` : compartiment qui contient le fichier manifeste correspondant au jeu de données.
+ `manifest_file` : nom de fichier et chemin d’accès du fichier manifeste.
```
aws rekognition create-dataset --project-arn {{project_arn}} \
--dataset-type {{type}} \
--dataset-source '{ "GroundTruthManifest": { "S3Object": { "Bucket": "{{bucket}}", "Name": "{{manifest_file}}" } } }' \
--profile custom-labels-access
--tags '{"key1": "value1", "key2": "value2"}'
```
------
#### [ Python ]
Utilisez les valeurs suivantes pour créer un jeu de données. Fournissez les paramètres de ligne de commande suivants :
+ `project_arn` : ARN du projet que vous souhaitez ajouter au jeu de données de test.
+ `dataset_type` : type de jeu de données que vous souhaitez créer (`train` ou `test`).
+ `bucket` : compartiment qui contient le fichier manifeste correspondant au jeu de données.
+ `manifest_file` : nom de fichier et chemin d’accès du fichier manifeste.
```
#Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
#PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-custom-labels-developer-guide/blob/master/LICENSE-SAMPLECODE.)
import argparse
import logging
import time
import json
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def create_dataset(rek_client, project_arn, dataset_type, bucket, manifest_file):
"""
Creates an Amazon Rekognition Custom Labels dataset.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param project_arn: The ARN of the project in which you want to create a dataset.
:param dataset_type: The type of the dataset that you want to create (train or test).
:param bucket: The S3 bucket that contains the manifest file.
:param manifest_file: The path and filename of the manifest file.
"""
try:
#Create the project
logger.info("Creating %s dataset for project %s",dataset_type, project_arn)
dataset_type = dataset_type.upper()
dataset_source = json.loads(
'{ "GroundTruthManifest": { "S3Object": { "Bucket": "'
+ bucket
+ '", "Name": "'
+ manifest_file
+ '" } } }'
)
response = rek_client.create_dataset(
ProjectArn=project_arn, DatasetType=dataset_type, DatasetSource=dataset_source
)
dataset_arn=response['DatasetArn']
logger.info("dataset ARN: %s",dataset_arn)
finished=False
while finished is False:
dataset=rek_client.describe_dataset(DatasetArn=dataset_arn)
status=dataset['DatasetDescription']['Status']
if status == "CREATE_IN_PROGRESS":
logger.info("Creating dataset: %s ",dataset_arn)
time.sleep(5)
continue
if status == "CREATE_COMPLETE":
logger.info("Dataset created: %s", dataset_arn)
finished=True
continue
if status == "CREATE_FAILED":
error_message = f"Dataset creation failed: {status} : {dataset_arn}"
logger.exception(error_message)
raise Exception (error_message)
error_message = f"Failed. Unexpected state for dataset creation: {status} : {dataset_arn}"
logger.exception(error_message)
raise Exception(error_message)
return dataset_arn
except ClientError as err:
logger.exception("Couldn't create dataset: %s",err.response['Error']['Message'])
raise
def add_arguments(parser):
"""
Adds command line arguments to the parser.
:param parser: The command line parser.
"""
parser.add_argument(
"project_arn", help="The ARN of the project in which you want to create the dataset."
)
parser.add_argument(
"dataset_type", help="The type of the dataset that you want to create (train or test)."
)
parser.add_argument(
"bucket", help="The S3 bucket that contains the manifest file."
)
parser.add_argument(
"manifest_file", help="The path and filename of the manifest file."
)
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()
print(f"Creating {args.dataset_type} dataset for project {args.project_arn}")
#Create the dataset.
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
dataset_arn=create_dataset(rekognition_client,
args.project_arn,
args.dataset_type,
args.bucket,
args.manifest_file)
print(f"Finished creating dataset: {dataset_arn}")
except ClientError as err:
logger.exception("Problem creating dataset: %s", err)
print(f"Problem creating dataset: {err}")
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
Utilisez les valeurs suivantes pour créer un jeu de données. Fournissez les paramètres de ligne de commande suivants :
+ `project_arn` : ARN du projet que vous souhaitez ajouter au jeu de données de test.
+ `dataset_type` : type de jeu de données que vous souhaitez créer (`train` ou `test`).
+ `bucket` : compartiment qui contient le fichier manifeste correspondant au jeu de données.
+ `manifest_file` : nom de fichier et chemin d’accès du fichier manifeste.
```
/*
Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
SPDX-License-Identifier: Apache-2.0
*/
package com.example.rekognition;
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.CreateDatasetRequest;
import software.amazon.awssdk.services.rekognition.model.CreateDatasetResponse;
import software.amazon.awssdk.services.rekognition.model.DatasetDescription;
import software.amazon.awssdk.services.rekognition.model.DatasetSource;
import software.amazon.awssdk.services.rekognition.model.DatasetStatus;
import software.amazon.awssdk.services.rekognition.model.DatasetType;
import software.amazon.awssdk.services.rekognition.model.DescribeDatasetRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeDatasetResponse;
import software.amazon.awssdk.services.rekognition.model.GroundTruthManifest;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import software.amazon.awssdk.services.rekognition.model.S3Object;
import java.util.logging.Level;
import java.util.logging.Logger;
public class CreateDatasetManifestFiles {
public static final Logger logger = Logger.getLogger(CreateDatasetManifestFiles.class.getName());
public static String createMyDataset(RekognitionClient rekClient, String projectArn, String datasetType,
String bucket, String name) throws Exception, RekognitionException {
try {
logger.log(Level.INFO, "Creating {0} dataset for project : {1} from s3://{2}/{3} ",
new Object[] { datasetType, projectArn, bucket, name });
DatasetType requestDatasetType = null;
switch (datasetType) {
case "train":
requestDatasetType = DatasetType.TRAIN;
break;
case "test":
requestDatasetType = DatasetType.TEST;
break;
default:
logger.log(Level.SEVERE, "Could not create dataset. Unrecognized dataset type: {0}", datasetType);
throw new Exception("Could not create dataset. Unrecognized dataset type: " + datasetType);
}
GroundTruthManifest groundTruthManifest = GroundTruthManifest.builder()
.s3Object(S3Object.builder().bucket(bucket).name(name).build()).build();
DatasetSource datasetSource = DatasetSource.builder().groundTruthManifest(groundTruthManifest).build();
CreateDatasetRequest createDatasetRequest = CreateDatasetRequest.builder().projectArn(projectArn)
.datasetType(requestDatasetType).datasetSource(datasetSource).build();
CreateDatasetResponse response = rekClient.createDataset(createDatasetRequest);
boolean created = false;
do {
DescribeDatasetRequest describeDatasetRequest = DescribeDatasetRequest.builder()
.datasetArn(response.datasetArn()).build();
DescribeDatasetResponse describeDatasetResponse = rekClient.describeDataset(describeDatasetRequest);
DatasetDescription datasetDescription = describeDatasetResponse.datasetDescription();
DatasetStatus status = datasetDescription.status();
logger.log(Level.INFO, "Creating dataset ARN: {0} ", response.datasetArn());
switch (status) {
case CREATE_COMPLETE:
logger.log(Level.INFO, "Dataset created");
created = true;
break;
case CREATE_IN_PROGRESS:
Thread.sleep(5000);
break;
case CREATE_FAILED:
String error = "Dataset creation failed: " + datasetDescription.statusAsString() + " "
+ datasetDescription.statusMessage() + " " + response.datasetArn();
logger.log(Level.SEVERE, error);
throw new Exception(error);
default:
String unexpectedError = "Unexpected creation state: " + datasetDescription.statusAsString() + " "
+ datasetDescription.statusMessage() + " " + response.datasetArn();
logger.log(Level.SEVERE, unexpectedError);
throw new Exception(unexpectedError);
}
} while (created == false);
return response.datasetArn();
} catch (RekognitionException e) {
logger.log(Level.SEVERE, "Could not create dataset: {0}", e.getMessage());
throw e;
}
}
public static void main(String[] args) {
String datasetType = null;
String bucket = null;
String name = null;
String projectArn = null;
String datasetArn = null;
final String USAGE = "\n" + "Usage: " + " \n\n" + "Where:\n"
+ " project_arn - the ARN of the project that you want to add copy the datast to.\n\n"
+ " dataset_type - the type of the dataset that you want to create (train or test).\n\n"
+ " bucket - the S3 bucket that contains the manifest file.\n\n"
+ " name - the location and name of the manifest file within the bucket.\n\n";
if (args.length != 4) {
System.out.println(USAGE);
System.exit(1);
}
projectArn = args[0];
datasetType = args[1];
bucket = args[2];
name = args[3];
try {
// Get the Rekognition client
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// Create the dataset
datasetArn = createMyDataset(rekClient, projectArn, datasetType, bucket, name);
System.out.println(String.format("Created dataset: %s", datasetArn));
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
} catch (Exception rekError) {
logger.log(Level.SEVERE, "Error: {0}", rekError.getMessage());
System.exit(1);
}
}
}
```
------
1. Si vous devez ajouter ou modifier des étiquettes, consultez [Gestion des étiquettes (kit SDK)](md-labels.md#md-labels-sdk).
1. Suivez les étapes décrites dans [Entraînement d’un modèle (kit SDK)](training-model.md#tm-sdk) pour entraîner le modèle.
## Créer une demande de jeu de données
Le format de la demande d' CreateDataset opération est le suivant :
```
{
"DatasetSource": {
"DatasetArn": "string",
"GroundTruthManifest": {
"S3Object": {
"Bucket": "string",
"Name": "string",
"Version": "string"
}
}
},
"DatasetType": "string",
"ProjectArn": "string",
"Tags": {
"string": "string"
}
}
```