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

# Obter segmentos do usuário com um trabalho de segmento em lote
<a name="creating-batch-seg-job"></a>

 Se você usou uma fórmula USER\$1SEGMENTATION, 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](item-affinity-recipe.md)) ou atributos do item ([Fórmula Item-Attribute-Affinity](item-attribute-affinity-recipe.md)) no formato JSON. 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](https://docs.aws.amazon.com/AmazonS3/latest/userguide/organizing-objects.html). 

**Topics**
+ [Criar um trabalho de segmento em lote (console)](#batch-segment-console)
+ [Criar um trabalho de segmento em lote (AWS CLI)](#batch-segment-cli)
+ [Criar um trabalho de segmento em lote (AWS SDKs)](#batch-segment-sdk)

## Criar um trabalho de segmento em lote (console)
<a name="batch-segment-console"></a>

 Depois de concluir [Como preparar dados de entrada para recomendações em lote](batch-data-upload.md), 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\$1SEGEMENTATION.

**Para criar um trabalho de segmento em lote (console)**

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

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

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

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

1. 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\$1SEGEMENTATION. 

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

1.  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://amzn-s3-demo-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](prepare-input-data-user-segment.md#batch-segment-job-json-examples). 

1. 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://amzn-s3-demo-bucket/<output folder name>/** 

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

1.  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](filter-batch.md#providing-filter-values). 

1. 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](tagging-resources.md).

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

1.  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)
<a name="batch-segment-cli"></a>

Depois de concluir [Como preparar dados de entrada para recomendações em lote](batch-data-upload.md), 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)](filter-batch.md). 

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)
<a name="batch-segment-sdk"></a>

Depois de concluir [Como preparar dados de entrada para recomendações em lote](batch-data-upload.md), 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://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 no JSON de entrada. Para obter mais informações, consulte [Como filtrar recomendações em lote e segmentos de usuários (recursos personalizados)](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();
```

------

O processamento do trabalho em lote pode demorar um pouco para ser concluído. É possível verificar o status de um trabalho chamando [DescribeBatchSegmentJob](API_DescribeBatchSegmentJob.md) 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](API_ListBatchSegmentJobs.md)