

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

# Criar um trabalho de inferência em lote
<a name="creating-batch-inference-job"></a>

 Crie trabalhos de inferência em lote para obter recomendações de itens em lote para os usuários com base nos dados de entrada do Amazon S3. Os dados de entrada podem ser uma lista de usuários ou itens (ou ambos) no formato JSON. Você pode criar um trabalho de inferência em lote com o console Amazon Personalize, AWS Command Line Interface o AWS CLI() ou. AWS SDKs 

 Ao criar um trabalho de inferência 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). 

 Para obter mais informações sobre o fluxo de trabalho em lote no Amazon Personalize, incluindo requisitos de permissões, pontuação de recomendações e preparação e importação de dados de entrada, consulte [Obter recomendações de itens em lote com recursos personalizados](getting-batch-recommendations.md). 

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

## Criar um trabalho de inferência em lote (console)
<a name="batch-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 inferência em lote. Esse procedimento pressupõe que você já criou uma solução e uma versão da solução (modelo treinado). 

**Para criar um trabalho de inferência 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. No painel de navegação, em **Recursos personalizados**, selecione **Trabalhos de inferência em lote**.

1. Escolha **Criar trabalho de inferência em lote**.

1.  Selecione o tipo de trabalho de inferência em lote. 
   + Para gerar recomendações de itens sem temas, selecione **Recomendações de itens**.
   +  Se você usar a fórmula Similar-Items e quiser adicionar temas descritivos a grupos de itens semelhantes, selecione **Recomendações temáticas com o Content Generator**. Para gerar temas, é necessário ter um conjunto de dados de itens com dados de nomes de itens e dados de texto. Para obter mais informações, consulte [Recomendações em lote com temas do Content Generator](themed-batch-recommendations.md). 

1. Em **Batch inference job details (Detalhes do trabalho de inferência em lote)**, em **Batch inference job name (Nome do trabalho de inferência em lote)**, especifique um nome para o trabalho de inferência 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. 

1. Em **Número de resultados**, especifique opcionalmente o número de recomendações para cada linha de dados de entrada. O padrão é 25.

1.  Se o trabalho em lote gerar recomendações com temas, em **Detalhes das recomendações temáticas**, selecione a coluna que contém nomes ou títulos dos itens no conjunto de dados de itens. Esses dados podem ajudar a gerar temas mais relevantes. Para obter mais informações, consulte [Recomendações em lote com temas do Content Generator](themed-batch-recommendations.md). 

1.  Em **Fonte da entrada**, especifique o caminho do Amazon S3 para o arquivo de entrada. 

   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 inferência em lote](batch-data-upload.md#batch-inference-job-json-examples). 

1. Para a **chave de descriptografia**, se você usar sua própria AWS KMS chave para criptografia de bucket, especifique o Amazon Resource Name (ARN) da sua chave. O Amazon Personalize deve ter permissão para usar a chave. Para obter informações sobre como conceder permissões, consulte [Conceder permissão ao Amazon Personalize para usar sua chave AWS KMS](granting-personalize-key-access.md). 

1. Em **Destino de saída**, especifique o caminho para o local de saída. Recomendamos usar um local diferente para os 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. Em **Chave de criptografia**, se você usar sua própria AWS KMS chave para criptografia, especifique o ARN da sua chave. O Amazon Personalize deve ter permissão para usar a chave. Para obter informações sobre como conceder permissões, consulte [Conceder permissão ao Amazon Personalize para usar sua chave AWS KMS](granting-personalize-key-access.md). 

1. Para o **perfil de serviço do IAM**, escolha o 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 buckets de entrada e saída do Amazon S3, respectivamente.

1.  Em **Filtros**, selecione um filtro a ser aplicado às recomendações em lote. 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 inferência em lote**. A criação de um trabalho de inferência em lote começa e a página **Batch inference jobs (Trabalhos de inferência em lote)** é aberta com a seção **Batch inference job detail (Detalhes do trabalho inferência em lote)** exibida.

    Quando o status do trabalho de inferência 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 inferência em lote (AWS CLI)
<a name="batch-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 inferência em lote com a operação [CreateBatchInferenceJob](API_CreateBatchInferenceJob.md). 

**Topics**
+ [Criar um trabalho de inferência em lote](#batch-cli-code-sample)
+ [Criar um trabalho de inferência em lote que gere temas](#batch-cli-themes)

### Criar um trabalho de inferência em lote
<a name="batch-cli-code-sample"></a>

 É possível usar o comando `create-batch-inference-job` para criar um trabalho de inferência em lote. 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. Opcionalmente, forneça um ARN de filtro para filtrar as recomendações. 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>/**. 

O exemplo inclui hiperparâmetros `itemExplorationConfig` opcionais específicos da fórmula User-Personalization: `explorationWeight` e `explorationItemAgeCutOff`. Opcionalmente, inclua os valores `explorationWeight` e `explorationItemAgeCutOff` para configurar a exploração. Para obter mais informações, consulte [Fórmula User-Personalization](native-recipe-new-item-USER_PERSONALIZATION.md). 

```
aws personalize create-batch-inference-job \
--job-name {{Batch job name}} \
--solution-version-arn {{Solution version ARN}} \
--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}} \
--batch-inference-job-config "{\"itemExplorationConfig\":{\"explorationWeight\":\"{{0.3}}\",\"explorationItemAgeCutOff\":\"{{30}}\"}}"
```

### Criar um trabalho de inferência em lote que gere temas
<a name="batch-cli-themes"></a>

Para gerar temas para itens semelhantes, é necessário usar a fórmula Similar-Items, e o conjunto de dados de itens deve ter um campo de texto e uma coluna de dados de nomes de itens. Para obter mais informações sobre recomendações com temas, consulte [Recomendações em lote com temas do Content Generator](themed-batch-recommendations.md).

O código a seguir cria um trabalho de inferência em lote que gera recomendações com temas. Mantenha o `batch-inference-job-mode` definido como `THEME_GENERATION`. Substitua `COLUMN_NAME` pelo nome da coluna que armazena os dados de nomes de itens. 

```
aws personalize create-batch-inference-job \
--job-name {{Themed batch job name}} \
--solution-version-arn {{Solution version ARN}} \
--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}} \
--batch-inference-job-mode THEME_GENERATION \
--theme-generation-config "{\"fieldsForThemeGeneration\": {\"itemName\":\"{{COLUMN_NAME}}\"}}"
```

## Criar um trabalho de inferência em lote (AWS SDKs)
<a name="batch-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 inferência em lote com a operação [CreateBatchInferenceJob](API_CreateBatchInferenceJob.md). 

**Topics**
+ [Criar um trabalho de inferência em lote](#batch-sdk-code-sample)
+ [Criar um trabalho de inferência em lote que gere temas](#batch-sdk-themes)

### Criar um trabalho de inferência em lote
<a name="batch-sdk-code-sample"></a>

 É possível usar o comando a seguir para criar um trabalho de inferência em lote. Especifique um nome de trabalho, o nome do recurso da Amazon (ARN) da versão da solução e o 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.

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 itens que você deseja que o Amazon Personalize preveja para cada linha de dados de entrada. Opcionalmente, forneça um ARN de filtro para filtrar as recomendações. 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) ]

O exemplo inclui hiperparâmetros `itemExplorationConfig` opcionais específicos da fórmula User-Personalization: `explorationWeight` e `explorationItemAgeCutOff`. Opcionalmente, inclua os valores `explorationWeight` e `explorationItemAgeCutOff` para configurar a exploração. Para obter mais informações, consulte [Fórmula User-Personalization](native-recipe-new-item-USER_PERSONALIZATION.md). 

```
import boto3

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

personalize_rec.create_batch_inference_job (
    solutionVersionArn = "{{Solution version ARN}}",
    jobName = "{{Batch job name}}",
    roleArn = "{{IAM service role ARN}}",
    filterArn = "{{Filter ARN}}",
    batchInferenceJobConfig = {
        # optional USER_PERSONALIZATION recipe hyperparameters
        "itemExplorationConfig": {      
            "explorationWeight": "{{0.3}}",
            "explorationItemAgeCutOff": "{{30}}"
        }
    },
    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 ]

O exemplo inclui campos `itemExplorationConfig` opcionais específicos da fórmula User-Personalization: `explorationWeight` e `explorationItemAgeCutOff`. Opcionalmente, inclua os valores `explorationWeight` e `explorationItemAgeCutOff` para configurar a exploração. Para obter mais informações, consulte [Fórmula User-Personalization](native-recipe-new-item-USER_PERSONALIZATION.md). 

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

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

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

      BatchInferenceJobInput jobInput = BatchInferenceJobInput.builder()
              .s3DataSource(inputSource)
              .build();
      BatchInferenceJobOutput jobOutputLocation = BatchInferenceJobOutput.builder()
              .s3DataDestination(outputDestination)
              .build();

      // Optional code to build the User-Personalization specific item exploration config.
      HashMap<String, String> explorationConfig = new HashMap<>();

      explorationConfig.put("explorationWeight", explorationWeight);
      explorationConfig.put("explorationItemAgeCutOff", explorationItemAgeCutOff);

      BatchInferenceJobConfig jobConfig = BatchInferenceJobConfig.builder()
              .itemExplorationConfig(explorationConfig)
              .build();
      // End optional User-Personalization recipe specific code.

      CreateBatchInferenceJobRequest createBatchInferenceJobRequest = CreateBatchInferenceJobRequest.builder()
              .solutionVersionArn(solutionVersionArn)
              .jobInput(jobInput)
              .jobOutput(jobOutputLocation)
              .jobName(jobName)
              .filterArn(filterArn)
              .roleArn(roleArn)
              .batchInferenceJobConfig(jobConfig)   // Optional
              .build();

      batchInferenceJobArn = personalizeClient.createBatchInferenceJob(createBatchInferenceJobRequest)
              .batchInferenceJobArn();
      DescribeBatchInferenceJobRequest describeBatchInferenceJobRequest = DescribeBatchInferenceJobRequest.builder()
              .batchInferenceJobArn(batchInferenceJobArn)
              .build();

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

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

          BatchInferenceJob batchInferenceJob = personalizeClient
                  .describeBatchInferenceJob(describeBatchInferenceJobRequest)
                  .batchInferenceJob();

          status = batchInferenceJob.status();
          System.out.println("Batch inference 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 batchInferenceJobArn;

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

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

```
// Get service clients module and commands using ES6 syntax.
import { CreateBatchInferenceJobCommand } 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 inference job's parameters.

export const createBatchInferenceJobParam = {
  jobName: "JOB_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 CreateBatchInferenceJobCommand(createBatchInferenceJobParam),
    );
    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 [DescribeBatchInferenceJob](API_DescribeBatchInferenceJob.md) e passando um `batchRecommendationsJobArn` como o parâmetro de entrada. Você também pode listar todos os trabalhos de inferência em lote do Amazon Personalize em seu AWS ambiente chamando. [ListBatchInferenceJobs](API_ListBatchInferenceJobs.md)

### Criar um trabalho de inferência em lote que gere temas
<a name="batch-sdk-themes"></a>

Para gerar temas para itens semelhantes, é necessário usar a fórmula Similar-Items, e o conjunto de dados de itens deve ter um campo de texto e uma coluna de dados de nomes de itens. Para obter mais informações sobre recomendações com temas, consulte [Recomendações em lote com temas do Content Generator](themed-batch-recommendations.md).

O código a seguir cria um trabalho de inferência em lote que gera recomendações com temas. Mantenha o `batchInferenceJobMode` definido como `"THEME_GENERATION"`. Substitua `COLUMNN_NAME` pelo nome da coluna que armazena os dados de nomes de itens. 

```
import boto3

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

personalize_rec.create_batch_inference_job (
    solutionVersionArn = "{{Solution version ARN}}",
    jobName = "{{Batch job name}}",
    roleArn = "{{IAM service role ARN}}",
    filterArn = "{{Filter ARN}}",
    batchInferenceJobMode = "THEME_GENERATION",
    themeGenerationConfig = {
      "fieldsForThemeGeneration": {
          "itemName": "{{COLUMN_NAME}}"
      }
    },
    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>/"}}
)
```