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.

# Obtenir des segments d'utilisateurs à l'aide d'une tâche de segmentation par lots
<a name="creating-batch-seg-job"></a>

 Si vous avez utilisé une recette USER\$1SEGMENTATION, vous pouvez créer des tâches de segmentation par lots pour obtenir des segments d'utilisateurs avec la version de votre solution. Chaque segment d'utilisateurs est trié par ordre décroissant en fonction de la probabilité que chaque utilisateur interagisse avec les articles de votre inventaire. Selon la recette, vos données d'entrée doivent être une liste d'éléments ([Recette Item-Affinity](item-affinity-recipe.md)) ou d'attributs d'éléments ([Item-Attribute-Affinity recette](item-attribute-affinity-recipe.md)) au format JSON. Vous pouvez créer une tâche de segmentation par lots à l'aide de la console Amazon Personalize, du AWS Command Line Interface (AWS CLI) ou AWS SDKs. 

 Lorsque vous créez une tâche de segmentation par lots, vous spécifiez les chemins Amazon S3 vers vos emplacements d'entrée et de sortie. Amazon S3 est basé sur un préfixe. Si vous fournissez un préfixe pour l'emplacement des données d'entrée, Amazon Personalize utilise tous les fichiers correspondant à ce préfixe comme données d'entrée. Par exemple, si vous fournissez `s3://amzn-s3-demo-bucket/folderName` un dossier dont le chemin est défini par le nom de compartiment`s3://amzn-s3-demo-bucket/folderName_test`, Amazon Personalize utilise tous les fichiers des deux dossiers comme données d'entrée. Pour utiliser uniquement les fichiers d'un dossier spécifique comme données d'entrée, terminez le chemin Amazon S3 par un délimiteur de préfixe, tel que `/` : `s3://amzn-s3-demo-bucket/folderName/` Pour plus d'informations sur la façon dont Amazon S3 organise les objets, consultez [Organisation, listage et utilisation de vos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/organizing-objects.html) objets. 

**Topics**
+ [Création d'une tâche de segmentation par lots (console)](#batch-segment-console)
+ [Création d'une tâche de segmentation par lots (AWS CLI)](#batch-segment-cli)
+ [Création d'une tâche de segmentation par lots (AWS SDKs)](#batch-segment-sdk)

## Création d'une tâche de segmentation par lots (console)
<a name="batch-segment-console"></a>

 Une fois que vous avez terminé[Préparation des données d'entrée pour les recommandations par lots](batch-data-upload.md), vous êtes prêt à créer une tâche de segmentation par lots. Cette procédure suppose que vous avez déjà créé une solution et une version de solution (modèle entraîné) avec une recette USER\$1SEGMENTATION.

**Pour créer une tâche de segmentation par lots (console)**

1. Ouvrez la console Amazon Personalize [https://console.aws.amazon.com/personalize/chez](https://console.aws.amazon.com/personalize/home) vous et connectez-vous à votre compte.

1. Sur la page du **groupe de jeux** de données, choisissez votre groupe de jeux de données.

1. Choisissez les tâches de **segmentation par lots** dans le volet de navigation, puis choisissez **Créer une tâche de segmentation par lots**.

1. Dans les **détails de la tâche de segment** **par lots, pour Nom de la tâche de segment par lots**, spécifiez un nom pour votre tâche de segment par lots.

1. Pour **Solution**, choisissez la solution, puis choisissez l'**ID de version de solution** que vous souhaitez utiliser pour générer les recommandations. Vous pouvez créer des tâches de segmentation par lots uniquement si vous avez utilisé une recette USER\$1SEGMENTATION. 

1. Pour **Nombre d'utilisateurs**, spécifiez éventuellement le nombre d'utilisateurs qu'Amazon Personalize génère pour chaque segment d'utilisateurs. La valeur par défaut est 25. Le maximum est de 5 millions.

1.  Pour **Source d'entrée**, spécifiez le chemin Amazon S3 vers votre fichier d'entrée ou utilisez le **bouton Parcourir S3** pour choisir votre compartiment Amazon S3.

   Utilisez la syntaxe suivante : **s3://amzn-s3-demo-bucket/<folder name>/<input JSON file name>.json**

    Vos données d'entrée doivent être au format adapté à la recette utilisée par votre solution. Pour des exemples de données d'entrée, voir[Exemples JSON d'entrée et de sortie de tâches de segmentation par lots](prepare-input-data-user-segment.md#batch-segment-job-json-examples). 

1. Pour **Destination de sortie**, spécifiez le chemin d'accès à votre emplacement de sortie ou utilisez le **bouton Parcourir S3** pour choisir votre compartiment Amazon S3. Nous vous recommandons d'utiliser un autre emplacement pour vos données de sortie (soit un dossier, soit un autre compartiment Amazon S3).

    Utilisez la syntaxe suivante : **s3://amzn-s3-demo-bucket/<output folder name>/** 

1. Pour le **rôle IAM**, choisissez l'une des options suivantes :
   +  Choisissez **Créer et utiliser un nouveau rôle de service** et entrez le **nom du rôle de service** pour créer un nouveau rôle, ou
   +  Si vous avez déjà créé un rôle avec les autorisations appropriées, choisissez **Utiliser un rôle de service existant** et choisissez le rôle IAM. 

    Le rôle que vous utilisez doit avoir un accès en lecture et en écriture à vos compartiments Amazon S3 d'entrée et de sortie respectivement.

1.  Pour **la configuration du filtre**, choisissez éventuellement un filtre pour appliquer un filtre aux segments d'utilisateurs. Si votre filtre utilise des paramètres d'espace réservé, assurez-vous que les valeurs des paramètres sont incluses dans le JSON d'entrée. Pour de plus amples informations, veuillez consulter [Fournir des valeurs de filtre dans votre JSON d'entrée](filter-batch.md#providing-filter-values). 

1. Pour les **balises**, ajoutez éventuellement des balises. Pour plus d'informations sur le balisage des ressources Amazon Personalize, consultez[Marquer les ressources Amazon Personalize](tagging-resources.md).

1.  Choisissez **Créer une tâche segmentée par lots**. La création des tâches de segment par **lots commence et la page Tâches de segment** **par lots apparaît avec la section détaillée des tâches de segment par lots** affichée.

1.  Lorsque le statut de la tâche de segmentation par lots **devient Active**, vous pouvez récupérer le résultat de la tâche dans le compartiment de sortie Amazon S3 désigné. Le nom du fichier de sortie est au format `input-name.out`. 

## Création d'une tâche de segmentation par lots (AWS CLI)
<a name="batch-segment-cli"></a>

Une fois que vous avez terminé[Préparation des données d'entrée pour les recommandations par lots](batch-data-upload.md), vous êtes prêt à créer une tâche de segmentation par lots à l'aide du `create-batch-segment-job` code suivant. Spécifiez un nom de tâche, remplacez-le `Solution version ARN` par le nom de ressource Amazon (ARN) de la version de votre solution et remplacez-le par l'`IAM service role ARN`ARN du rôle de service IAM que vous avez créé pour Amazon Personalize lors de la configuration. Ce rôle doit avoir un accès en lecture et en écriture à vos compartiments Amazon S3 d'entrée et de sortie respectivement. Pour `num-results` spécifier le nombre d'utilisateurs que vous souhaitez qu'Amazon Personalize prédise pour chaque ligne de données d'entrée. La valeur par défaut est 25. Le maximum est de 5 millions. Fournissez éventuellement un `filter-arn` pour filtrer les segments d'utilisateurs. Si votre filtre utilise des paramètres d'espace réservé, assurez-vous que les valeurs des paramètres sont incluses dans le JSON d'entrée. Pour de plus amples informations, veuillez consulter [Filtrer les recommandations par lots et les segments d'utilisateurs (ressources personnalisées)](filter-batch.md). 

Remplacez `S3 input path` et `S3 output path` par le chemin Amazon S3 menant à votre fichier d'entrée et à votre emplacement de sortie. Nous vous recommandons d'utiliser un autre emplacement pour vos données de sortie (soit un dossier, soit un autre compartiment Amazon S3). Utilisez la syntaxe suivante pour les emplacements d'entrée et de sortie : **s3://amzn-s3-demo-bucket/<folder name>/<input JSON file name>.json** et**s3://amzn-s3-demo-bucket/<output folder name>/**. 

```
aws personalize create-batch-segment-job \
                --job-name Job name \
                --solution-version-arn Solution version ARN \
                --num-results The number of predicted users \
                --filter-arn Filter ARN \
                --job-input s3DataSource={path=s3://S3 input path} \
                --job-output s3DataDestination={path=s3://S3 output path} \
                --role-arn IAM service role ARN
{
   "batchSegmentJobArn": "arn:aws:personalize:us-west-2:acct-id:batch-segment-job/batchSegmentJobName"
}
```

## Création d'une tâche de segmentation par lots (AWS SDKs)
<a name="batch-segment-sdk"></a>

Une fois que vous avez terminé[Préparation des données d'entrée pour les recommandations par lots](batch-data-upload.md), vous êtes prêt à créer une tâche de segmentation par lots avec l'`CreateBatchSegmentJob`opération. Le code suivant montre comment créer une tâche de segmentation par lots. Donnez un nom à la tâche, spécifiez l'Amazon Resource Name (ARN) de la version de solution à utiliser, spécifiez l'ARN de votre rôle Amazon Personalize IAM et spécifiez le chemin Amazon S3 vers votre fichier d'entrée et les emplacements de sortie. Votre rôle de service IAM doit disposer d'un accès en lecture et en écriture à vos compartiments Amazon S3 d'entrée et de sortie respectivement. 

Nous vous recommandons d'utiliser un autre emplacement pour vos données de sortie (soit un dossier, soit un autre compartiment Amazon S3). Utilisez la syntaxe suivante pour les emplacements d'entrée et de sortie : **s3://amzn-s3-demo-bucket/<folder name>/<input JSON file name>.json** et**s3://amzn-s3-demo-bucket/<output folder name>/**. 

 Spécifiez `numResults` le nombre d'utilisateurs que vous souhaitez qu'Amazon Personalize prédise pour chaque ligne de données d'entrée. La valeur par défaut est 25. Le maximum est de 5 millions. Fournissez éventuellement un `filterArn` pour filtrer les segments d'utilisateurs. Si votre filtre utilise des paramètres d'espace réservé, assurez-vous que les valeurs des paramètres sont incluses dans le JSON d'entrée. Pour de plus amples informations, veuillez consulter [Filtrer les recommandations par lots et les segments d'utilisateurs (ressources personnalisées)](filter-batch.md). 

------
#### [ SDK for Python (Boto3) ]

```
import boto3

personalize_rec = boto3.client(service_name='personalize')

personalize_rec.create_batch_segment_job (
    solutionVersionArn = "Solution version ARN",
    jobName = "Job name",
    numResults = 25,
    filterArn = "Filter ARN",
    roleArn = "IAM service role ARN",
    jobInput = 
       {"s3DataSource": {"path": "s3://amzn-s3-demo-bucket/<folder name>/<input JSON file name>.json"}},
    jobOutput = 
       {"s3DataDestination": {"path": "s3://amzn-s3-demo-bucket/<output folder name>/"}}
)
```

------
#### [ SDK for Java 2.x ]

```
public static String createBatchSegmentJob(PersonalizeClient personalizeClient,
                                                        String solutionVersionArn,
                                                        String jobName,
                                                        String filterArn,
                                                        int numResults,
                                                        String s3InputDataSourcePath,
                                                        String s3DataDestinationPath,
                                                        String roleArn,
                                                        String explorationWeight,
                                                        String explorationItemAgeCutOff) {

  long waitInMilliseconds = 60 * 1000;
  String status;
  String batchSegmentJobArn;

  try {
      // Set up data input and output parameters.
      S3DataConfig inputSource = S3DataConfig.builder()
              .path(s3InputDataSourcePath)
              .build();
      S3DataConfig outputDestination = S3DataConfig.builder()
              .path(s3DataDestinationPath)
              .build();

      BatchSegmentJobInput jobInput = BatchSegmentJobInput.builder()
              .s3DataSource(inputSource)
              .build();
      BatchSegmentJobOutput jobOutputLocation = BatchSegmentJobOutput.builder()
              .s3DataDestination(outputDestination)
              .build();


      CreateBatchSegmentJobRequest createBatchSegmentJobRequest = CreateBatchSegmentJobRequest.builder()
              .solutionVersionArn(solutionVersionArn)
              .filterArn(filterArn)
              .jobInput(jobInput)
              .jobOutput(jobOutputLocation)
              .jobName(jobName)
              .numResults(numResults)
              .roleArn(roleArn)
              .build();

      batchSegmentJobArn = personalizeClient.createBatchSegmentJob(createBatchSegmentJobRequest)
              .batchSegmentJobArn();
      DescribeBatchSegmentJobRequest describeBatchSegmentJobRequest = DescribeBatchSegmentJobRequest.builder()
              .batchSegmentJobArn(batchSegmentJobArn)
              .build();

      long maxTime = Instant.now().getEpochSecond() + 3 * 60 * 60;

      // wait until the batch segment job is complete.
      while (Instant.now().getEpochSecond() < maxTime) {

          BatchSegmentJob batchSegmentJob = personalizeClient
                  .describeBatchSegmentJob(describeBatchSegmentJobRequest)
                  .batchSegmentJob();

          status = batchSegmentJob.status();
          System.out.println("batch segment job status: " + status);

          if (status.equals("ACTIVE") || status.equals("CREATE FAILED")) {
              break;
          }
          try {
              Thread.sleep(waitInMilliseconds);
          } catch (InterruptedException e) {
              System.out.println(e.getMessage());
          }
      }
      return batchSegmentJobArn;

  } catch (PersonalizeException e) {
      System.out.println(e.awsErrorDetails().errorMessage());
  }
  return "";
}
```

------
#### [ SDK for JavaScript v3 ]

```
// Get service clients module and commands using ES6 syntax.
import { CreateBatchSegmentJobCommand } from "@aws-sdk/client-personalize";
import { personalizeClient } from "./libs/personalizeClients.js";

// Or, create the client here.
// const personalizeClient = new PersonalizeClient({ region: "REGION"});

// Set the batch segment job's parameters.

export const createBatchSegmentJobParam = {
  jobName: "NAME",
  jobInput: {
    s3DataSource: {
      path: "INPUT_PATH",
    },
  },
  jobOutput: {
    s3DataDestination: {
      path: "OUTPUT_PATH",
    },
  },
  roleArn: "ROLE_ARN",
  solutionVersionArn: "SOLUTION_VERSION_ARN",
  numResults: 20,
};

export const run = async () => {
  try {
    const response = await personalizeClient.send(
      new CreateBatchSegmentJobCommand(createBatchSegmentJobParam),
    );
    console.log("Success", response);
    return response; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

------

Le traitement de la tâche par lots peut prendre un certain temps. Vous pouvez vérifier l'état d'une tâche en appelant [DescribeBatchSegmentJob](API_DescribeBatchSegmentJob.md) et en transmettant un `batchSegmentJobArn` comme paramètre d'entrée. Vous pouvez également répertorier toutes les tâches de segmentation par lots Amazon Personalize de votre AWS environnement en appelant[ListBatchSegmentJobs](API_ListBatchSegmentJobs.md).