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

Si vous avez utilisé une SEGMENTATION recette USER _, 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) ou d'attributs d'articles (Recette Item-Attribut-Affinity) au JSON format. 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 compartiments3://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 objets.

Création d'une tâche de segmentation par lots (console)

Une fois que vous avez terminéPréparation des données d'entrée pour les recommandations par lots, 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 SEGEMENTATION recette USER _.

Création d'une tâche de segmentation par lots (AWS CLI)

Une fois que vous avez terminéPréparation des données d'entrée pour les recommandations par lots, 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 IAM service role ARN par le rôle ARN de IAM service 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 votre saisieJSON. Pour de plus amples informations, veuillez consulter Filtrer les recommandations par lots et les segments d'utilisateurs (ressources personnalisées).

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 ets3://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)

Une fois que vous avez terminéPréparation des données d'entrée pour les recommandations par lots, vous êtes prêt à créer une tâche de segmentation par lots avec l'CreateBatchSegmentJobopération. Le code suivant montre comment créer une tâche de segmentation par lots. Donnez un nom à la tâche, spécifiez le nom de ressource Amazon (ARN) de la version de solution à utiliser, spécifiez le nom ARN correspondant à votre IAM rôle Amazon Personalize et spécifiez le chemin Amazon S3 vers votre fichier d'entrée et votre emplacement de sortie. Votre rôle IAM de service 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 ets3://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 votre saisieJSON. Pour de plus amples informations, veuillez consulter Filtrer les recommandations par lots et les segments d'utilisateurs (ressources personnalisées).

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: {         /* required */
    s3DataSource: {   /* required */
      path: 'INPUT_PATH', /* required */
      // kmsKeyArn: 'INPUT_KMS_KEY_ARN' /* optional */'
    }
  },
  jobOutput: {         /* required */
    s3DataDestination: {   /* required */
      path: 'OUTPUT_PATH', /* required */
      // kmsKeyArn: 'OUTPUT_KMS_KEY_ARN' /* optional */'
    }
  },
  roleArn: 'ROLE_ARN', /* required */
  solutionVersionArn: 'SOLUTION_VERSION_ARN', /* required */
  numResults: 20 /* optional */
};

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 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 appelantListBatchSegmentJobs.