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.

# Ajout d’un jeu de données à un projet
<a name="md-add-dataset"></a>

Vous pouvez ajouter un jeu de données d’entraînement ou un jeu de données de test à un projet existant. Si vous souhaitez remplacer un jeu de données existant, supprimez d’abord le jeu de données existant. Pour plus d’informations, consultez [Suppression d’un jeu de données](md-delete-dataset.md). Ajoutez ensuite le nouveau jeu de données. 

**Topics**
+ [Ajout d’un jeu de données à un projet (console)](#md-add-dataset-console)
+ [Ajout d’un jeu de données à un projet (kit SDK)](#md-add-dataset-sdk)

## Ajout d’un jeu de données à un projet (console)
<a name="md-add-dataset-console"></a>

Vous pouvez ajouter un jeu de données d’entraînement ou de test à un projet à l’aide de la console Étiquettes personnalisées Amazon Rekognition.

**Pour ajouter un jeu de données à un projet**

1. Ouvrez la console Amazon Rekognition à l'adresse. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)

1. Dans le volet de gauche, choisissez **Utiliser Custom Labels**. La page d’accueil d’Étiquettes personnalisées Amazon Rekognition s’affiche. 

1. Dans le volet de navigation de gauche, choisissez **Projets**. La vue Projets s’affiche.

1. Choisissez le projet auquel vous souhaitez ajouter un jeu de données. 

1. Dans le volet de navigation de gauche, sous le nom du projet, choisissez **Ensembles de données**.

1. Si le projet ne possède pas de jeu de données existant, la page **Créer un jeu de données** s’affiche. Procédez comme suit :

   1. Sur la page **Créer un jeu de données**, entrez les informations relatives à la source de l’image. Pour plus d’informations, consultez [Création de jeux de données d’entraînement et de test avec des images](md-create-dataset.md). 

   1. Choisissez **Créer un jeu de données** pour créer le jeu de données.

1. Si le projet possède un jeu de données existant (entraînement ou test), la page des détails du projet s’affiche. Procédez comme suit : 

   1. Sur la page des détails du projet, choisissez **Actions**.

   1. Si vous souhaitez ajouter un jeu de données d’entraînement, choisissez **Créer un jeu de données d’entraînement**.

   1. Si vous souhaitez ajouter un jeu de données de test, choisissez **Créer un jeu de données de test**.

   1. Sur la page **Créer un jeu de données**, entrez les informations relatives à la source de l’image. Pour plus d’informations, consultez [Création de jeux de données d’entraînement et de test avec des images](md-create-dataset.md). 

   1. Choisissez **Créer un jeu de données** pour créer le jeu de données.

1. Ajoutez des images à votre jeu de données. Pour plus d’informations, consultez [Ajout d’autres images (console)](md-add-images.md#md-add-images-console).

1. Ajoutez des étiquettes à votre jeu de données. Pour plus d’informations, consultez [Ajout de nouvelles étiquettes (console)](md-labels.md#md-add-new-labels).

1. Ajoutez des étiquettes à vos images. Si vous ajoutez des étiquettes au niveau de l’image, consultez [Attribution d’étiquettes au niveau de l’image à une image](md-assign-image-level-labels.md). Si vous ajoutez des cadres de délimitation, consultez [Étiquetage des objets à l’aide de cadres de délimitation](md-localize-objects.md). Pour plus d’informations, consultez [Utilisation des jeux de données](md-dataset-purpose.md).

## Ajout d’un jeu de données à un projet (kit SDK)
<a name="md-add-dataset-sdk"></a>

Vous pouvez ajouter un jeu de données d’entraînement ou de test à un projet existant des façons suivantes :
+ Créez un jeu de données à l’aide d’un fichier manifeste. Pour plus d’informations, consultez [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éez un jeu de données vide et remplissez-le ensuite. L’exemple suivant montre comment créer un jeu de données vide. Pour ajouter des entrées après avoir créé un jeu de données vide, consultez [Ajout d’autres images à un jeu de données](md-add-images.md).

**Topics**

**Pour ajouter un jeu de données à un projet (kit SDK)**

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. Utilisez les exemples suivants pour ajouter des lignes JSON à un jeu de données.

------
#### [ CLI ]

   Remplacez `project_arn` par le projet auquel vous souhaitez ajouter le jeu de données. Remplacez `dataset_type` par `TRAIN` pour créer un jeu de données d’entraînement ou `TEST` pour créer un jeu de données de test. 

   ```
   aws rekognition create-dataset --project-arn {{project_arn}} \
     --dataset-type {{dataset_type}} \
     --profile custom-labels-access
   ```

------
#### [ Python ]

   Utilisez le code suivant pour créer un jeu de données. Fournissez l’options de ligne de commande suivantes :
   + `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 (entraînement ou test).

   ```
   # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
   # SPDX-License-Identifier: Apache-2.0
   
   import argparse
   import logging
   import time
   import boto3
   
   from botocore.exceptions import ClientError
   
   logger = logging.getLogger(__name__)
   
   def create_empty_dataset(rek_client, project_arn, dataset_type):
       """
       Creates an empty 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).
       """
   
       try:
           #Create the dataset.
           logger.info("Creating empty %s dataset for project %s",
               dataset_type, project_arn)
   
           dataset_type=dataset_type.upper()
   
           response = rek_client.create_dataset(
               ProjectArn=project_arn, DatasetType=dataset_type
           )
   
           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 empty dataset."
       )
   
       parser.add_argument(
           "dataset_type", help="The type of the empty dataset that you want to create (train or test)."
       )
   
   
   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 empty {args.dataset_type} dataset for project {args.project_arn}")
   
           # Create the empty dataset.
           session = boto3.Session(profile_name='custom-labels-access')
           rekognition_client = session.client("rekognition")
   
           dataset_arn=create_empty_dataset(rekognition_client, 
               args.project_arn,
               args.dataset_type.lower())
   
           print(f"Finished creating empty dataset: {dataset_arn}")
   
   
       except ClientError as err:
           logger.exception("Problem creating empty dataset: %s", err)
           print(f"Problem creating empty dataset: {err}")
       except Exception as err:
           logger.exception("Problem creating empty dataset: %s", err)
           print(f"Problem creating empty dataset: {err}")
   
   
   if __name__ == "__main__":
       main()
   ```

------
#### [ Java V2 ]

   Utilisez le code suivant pour créer un jeu de données. Fournissez l’options de ligne de commande suivantes :
   + `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 (entraînement ou test).

   ```
   /*
      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.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.RekognitionException;
   
   import java.net.URI;
   import java.util.logging.Level;
   import java.util.logging.Logger;
   
   public class CreateEmptyDataset {
   
       public static final Logger logger = Logger.getLogger(CreateEmptyDataset.class.getName());
   
       public static String createMyEmptyDataset(RekognitionClient rekClient, String projectArn, String datasetType)
               throws Exception, RekognitionException {
   
           try {
   
               logger.log(Level.INFO, "Creating empty {0} dataset for project : {1}",
                       new Object[] { datasetType.toString(), projectArn });
   
               DatasetType requestDatasetType = null;
   
               switch (datasetType) {
               case "train":
                   requestDatasetType = DatasetType.TRAIN;
                   break;
               case "test":
                   requestDatasetType = DatasetType.TEST;
                   break;
               default:
                   logger.log(Level.SEVERE, "Unrecognized dataset type: {0}", datasetType);
                   throw new Exception("Unrecognized dataset type: " + datasetType);
   
               }
   
               CreateDatasetRequest createDatasetRequest = CreateDatasetRequest.builder().projectArn(projectArn)
                       .datasetType(requestDatasetType).build();
   
               CreateDatasetResponse response = rekClient.createDataset(createDatasetRequest);
   
               boolean created = false;
               
               //Wait until updates finishes
   
               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 datasetArn = null;
           String projectArn = null;
   
   
           final String USAGE = "\n" + "Usage: " + "<project_arn> <dataset_type>\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 empty dataset that you want to create (train or test).\n\n";
                 
   
           if (args.length != 2) {
               System.out.println(USAGE);
               System.exit(1);
           }
   
           projectArn = args[0];
           datasetType = args[1];
           
           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 = createMyEmptyDataset(rekClient, projectArn, datasetType);
   
               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. Ajoutez des images au jeu de données. Pour plus d’informations, consultez [Ajout d’autres images (kit SDK)](md-add-images.md#md-add-images-sdk).