Criar um trabalho de segmento em lote

Se você usou uma fórmula USER_SEGMENTATION, 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 fórmula, seus dados de entrada devem ser uma lista de itens (Fórmula de Item-Affinity) ou atributos do item (Fórmula Item-Attribute-Affinity) no formato JSON. Você pode criar um trabalho de segmento em lotes com o console Amazon Personalize, o AWS Command Line Interface (AWS CLI) ou AWS os 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://<name of your S3 bucket>/folderName e seu bucket também tiver uma pasta com um caminho de s3://<name of your S3 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://<name of your S3 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á criou uma solução e uma versão da solução (modelo treinado) com uma fórmula USER_SEGEMENTATION.

Para criar um trabalho de segmento em lote (console)

1. Abra o console do Amazon Personalize em https://console.aws.amazon.com/personalize/home e faça login na sua conta.

2. Na página Grupos de conjuntos de dados, escolha seu grupo de conjuntos de dados.

3. Escolha Trabalhos de segmentos em lote no painel de navegação, depois escolha Criar trabalho de segmento em lote.

4. Em Detalhes do trabalho de segmento em lote, em Nome do trabalho do segmento em lote, especifique um nome para o trabalho de segmento em lote.

5. Em Solução, escolha a solução e, em seguida, escolha a ID da versão da solução que você deseja usar para gerar as recomendações. Você pode criar trabalhos de segmentos em lote somente se tiver usado uma fórmula USER_SEGEMENTATION.

6. Em Número de usuários, é possível especificar o número de usuários que o Amazon Personalize gera para cada segmento de usuário. O padrão é 25. O máximo é 5 milhões.

7. Em Fonte de entrada, especifique o caminho do Amazon S3 para seu arquivo de entrada ou use Procurar no S3 para escolher seu bucket do Amazon S3.

   Use a seguinte sintaxe: s3://<name of your S3 bucket>/<folder name>/<input JSON file name>.json

   Seus dados de entrada devem estar no formato correto para a fórmula que sua solução usa. Para exemplos de dados de entrada, consulte Exemplos de JSON de entrada e saída de trabalho de segmento em lote.

8. Em Destino de saída, especifique o caminho para seu local de saída ou use Procurar no S3 para escolher seu bucket do Amazon S3. Recomendamos usar um local diferente para seus dados de saída (uma pasta ou um bucket diferente do Amazon S3).

   Use a seguinte sintaxe: s3://<name of your S3 bucket>/<output folder name>/

9. Para Perfil do IAM, escolha uma das seguintes opções:

   • Escolha Criar e usar novo perfil de serviço e insira o Nome do perfil de serviço para criar um novo perfil ou

   • Se você já criou um perfil com as permissões corretas, escolha Usar um perfil de serviço existente e escolha o perfil do IAM.

   O perfil usado deve ter acesso de leitura e gravação aos seus buckets de entrada e saída do Amazon S3, respectivamente.

10. Para Configuração do filtro, é possível escolher um filtro a ser aplicado aos 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 no JSON de entrada. Para obter mais informações, consulte Como fornecer valores de filtro no seu JSON de entrada.

11. Para Tags, é possível adicionar quaisquer tags. Para obter mais informações sobre recursos de atribuição de tags do Amazon Personalize, consulte Usar tags nos recursos do Amazon Personalize.

12. Escolha Criar trabalho de segmento em lote. A criação de um trabalho de segmento em lote começa, e a página Trabalhos de segmentos em lote é aberta com a seção Detalhes do trabalho de segmento em lote exibida.

13. Quando o status do trabalho de segmento em lote muda para Ativo, é possível recuperar a saída do trabalho no bucket de saída designado do Amazon S3. O nome do arquivo de saída terá o formato input-name.out.

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, substitua Solution version ARN pelo nome do recurso da Amazon (ARN) da versão da solução e substitua IAM service role ARN pelo ARN do perfil de serviço do IAM 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 no JSON de entrada. 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://<name of your S3 bucket>/<folder name>/<input JSON file name>.json e s3://<name of your S3 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"
}

Criação de uma tarefa 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 nome do recurso da Amazon (ARN) da versão da solução a ser usada, o ARN do perfil do IAM do Amazon Personalize e o caminho do Amazon S3 para seu arquivo de entrada e locais de saída. O perfil de serviço do IAM 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://<name of your S3 bucket>/<folder name>/<input JSON file name>.json e s3://<name of your S3 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 no JSON de entrada. 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://<name of your S3 bucket>/<folder name>/<input JSON file name>.json"}},
    jobOutput = 
       {"s3DataDestination": {"path": "s3://<name of your S3 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