As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Obtendo segmentos de usuários com uma tarefa de segmentação em lote

Se você usou uma SEGMENTATION receita USER _, você pode criar trabalhos de segmentos em lote para obter segmentos de usuários com sua versão da solução. Cada segmento de usuário é classificado em ordem decrescente com base na probabilidade de cada usuário interagir com os itens do seu inventário. Dependendo da receita, seus dados de entrada devem ser uma lista de itens (Fórmula de Item-Affinity) ou atributos do item (Fórmula Item-Attribute-Affinity) em JSON formato. Você pode criar um trabalho de segmento em lote com o console Amazon Personalize, o AWS Command Line Interface (AWS CLI) ou. AWS SDKs

Ao criar um trabalho de segmento em lote, especifique os caminhos do Amazon S3 para seus locais de entrada e saída. O Amazon S3 é baseado em prefixos. Se você fornecer um prefixo para a localização dos dados de entrada, o Amazon Personalize usará todos os arquivos correspondentes a esse prefixo como dados de entrada. Por exemplo, se você fornecer s3://amzn-s3-demo-bucket/folderName e seu bucket também tiver uma pasta com um caminho de s3://amzn-s3-demo-bucket/folderName_test, o Amazon Personalize usará todos os arquivos em ambas as pastas como dados de entrada. Para usar somente os arquivos dentro de uma pasta específica como dados de entrada, termine o caminho do Amazon S3 com um delimitador de prefixo, como /: s3://amzn-s3-demo-bucket/folderName/ Para obter mais informações sobre como o Amazon S3 organiza objetos, consulte Organizar, listar e trabalhar com seus objetos.

Criar um trabalho de segmento em lote (console)

Depois de concluir Como preparar dados de entrada para recomendações em lote, você estará pronto para criar um trabalho de segmento em lote. Esse procedimento pressupõe que você já tenha criado uma solução e uma versão da solução (modelo treinado) com uma SEGEMENTATION receita USER _.

Criar um trabalho de segmento em lote (AWS CLI)

Depois de concluir Como preparar dados de entrada para recomendações em lote, você estará pronto para criar um trabalho de segmento em lote usando o código create-batch-segment-job a seguir. Especifique um nome de trabalho, Solution version ARN substitua pelo Amazon Resource Name (ARN) da versão da sua solução e IAM service role ARN substitua pelo da função ARN de IAM serviço que você criou para o Amazon Personalize durante a configuração. Esse perfil deve ter acesso de leitura e gravação aos seus buckets de entrada e saída do Amazon S3, respectivamente. Para num-results, especifique o número de usuários que você deseja que o Amazon Personalize preveja para cada linha de dados de entrada. O padrão é 25. O máximo é 5 milhões. Como opção, forneça um filter-arn para filtrar segmentos de usuários. Se o filtro usar parâmetros de espaço reservado, verifique se os valores dos parâmetros estão incluídos na sua entradaJSON. Para obter mais informações, consulte Como filtrar recomendações em lote e segmentos de usuários (recursos personalizados).

Substitua S3 input path e S3 output path pelo caminho do Amazon S3 para seu arquivo de entrada e locais de saída. Recomendamos usar um local diferente para seus dados de saída (uma pasta ou um bucket diferente do Amazon S3). Use a seguinte sintaxe para locais de entrada e saída: s3://amzn-s3-demo-bucket/<folder name>/<input JSON file name>.json e 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"
}

Criar um trabalho de segmento em lote (AWS SDKs)

Depois de concluir Como preparar dados de entrada para recomendações em lote, você estará pronto para criar um trabalho de segmento em lote com a operação CreateBatchSegmentJob. O código a seguir mostra como criar um trabalho de segmento em lote. Dê um nome ao trabalho, especifique o Amazon Resource Name (ARN) da versão da solução a ser usada, especifique a ARN para sua IAM função Amazon Personalize e especifique o caminho do Amazon S3 para seu arquivo de entrada e locais de saída. Sua função IAM de serviço deve ter acesso de leitura e gravação aos seus buckets de entrada e saída do Amazon S3, respectivamente.

Recomendamos usar um local diferente para seus dados de saída (uma pasta ou um bucket diferente do Amazon S3). Use a seguinte sintaxe para locais de entrada e saída: s3://amzn-s3-demo-bucket/<folder name>/<input JSON file name>.json e s3://amzn-s3-demo-bucket/<output folder name>/.

Para numResults, especifique o número de usuários que você deseja que o Amazon Personalize preveja para cada linha de dados de entrada. O padrão é 25. O máximo é 5 milhões. Como opção, forneça um filterArn para filtrar segmentos de usuários. Se o filtro usar parâmetros de espaço reservado, verifique se os valores dos parâmetros estão incluídos na sua entradaJSON. Para obter mais informações, consulte Como filtrar recomendações em lote e segmentos de usuários (recursos personalizados).

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();

O processamento do trabalho em lote pode demorar um pouco para ser concluído. É possível verificar o status de um trabalho chamando DescribeBatchSegmentJob e passando um batchSegmentJobArn como o parâmetro de entrada. Você também pode listar todos os trabalhos de segmento em lote do Amazon Personalize em seu AWS ambiente ligando para. ListBatchSegmentJobs