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

# Conceitos básicos (SDK for Java 2.x)
<a name="getting-started-java"></a>

Este tutorial mostra como concluir o fluxo de trabalho do Amazon Personalize com o AWS SDK for Java 2.x. 

Depois de concluir este exercício, exclua os recursos que você criou para evitar cobranças desnecessárias. Para obter mais informações, consulte [Requisitos para excluir recursos do Amazon Personalize](deleting-resources.md). 

Para obter mais exemplos de , consulte [Projeto completo do Amazon Personalize](#gs-java-example).

**Topics**
+ [Pré-requisitos](#gs-java-prerequisites)
+ [Projeto completo do Amazon Personalize](#gs-java-example)

## Pré-requisitos
<a name="gs-java-prerequisites"></a>

Este tutorial tem os seguintes pré-requisitos:
+ Conclua [Pré-requisitos de conceitos básicos](gs-prerequisites.md) para configurar as permissões necessárias e criar os dados de treinamento. Você pode usar a mesma fonte de dados listada nos exercícios [Conceitos básicos (console)](getting-started-console.md) ou [Conceitos básicos (AWS CLI)](getting-started-cli.md). Se estiver usando seus próprios dados de origem, verifique se eles estão formatados de acordo com os requisitos.
+ Configure as credenciais do SDK for Java 2.x e da AWS conforme especificado no procedimento [Configurar o AWS SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html) no *Guia do desenvolvedor do AWS SDK for Java 2.x*. 

### Tutorial
<a name="gs-custom-java-tutorial"></a>

Nas etapas a seguir, você vai configurar seu projeto para usar pacotes do Amazon Personalize e criar clientes do SDK para Java 2.x do Amazon Personalize. Em seguida, importará dados, criará e implantará uma versão da solução com uma campanha e receberá recomendações.

#### Etapa 1: Configurar seu projeto para usar pacotes do Amazon Personalize
<a name="gs-java-set-up-project"></a>

Depois de concluir as etapas obrigatórias, adicione dependências do Amazon Personalize ao seu arquivo pom.xml e importe pacotes do Amazon Personalize. 

1.  Adicione as dependências a seguir ao arquivo pom.xml. Os números da versão mais recente podem ser diferentes do código de exemplo. 

   ```
   <dependency>
   	<groupId>software.amazon.awssdk</groupId>
   	<artifactId>personalize</artifactId>
   	<version>2.16.83</version>
   </dependency>
   <dependency>
   	<groupId>software.amazon.awssdk</groupId>
   	<artifactId>personalizeruntime</artifactId>
   	<version>2.16.83</version>
   </dependency>
   <dependency>
   	<groupId>software.amazon.awssdk</groupId>
   	<artifactId>personalizeevents</artifactId>
   	<version>2.16.83</version>
   </dependency>
   ```

1.  Adicione as seguintes instruções de importação ao seu projeto. 

   ```
   // import client packages
   import software.amazon.awssdk.services.personalize.PersonalizeClient;
   import software.amazon.awssdk.services.personalizeruntime.PersonalizeRuntimeClient;
   // Amazon Personalize exception package
   import software.amazon.awssdk.services.personalize.model.PersonalizeException;
   // schema packages
   import software.amazon.awssdk.services.personalize.model.CreateSchemaRequest;
   // dataset group packages
   import software.amazon.awssdk.services.personalize.model.CreateDatasetGroupRequest;
   import software.amazon.awssdk.services.personalize.model.DescribeDatasetGroupRequest;
   // dataset packages
   import software.amazon.awssdk.services.personalize.model.CreateDatasetRequest;
   // dataset import job packages
   import software.amazon.awssdk.services.personalize.model.CreateDatasetImportJobRequest;
   import software.amazon.awssdk.services.personalize.model.DataSource;
   import software.amazon.awssdk.services.personalize.model.DatasetImportJob;
   import software.amazon.awssdk.services.personalize.model.DescribeDatasetImportJobRequest;
   // solution packages
   import software.amazon.awssdk.services.personalize.model.CreateSolutionRequest;
   import software.amazon.awssdk.services.personalize.model.CreateSolutionResponse;
   // solution version packages
   import software.amazon.awssdk.services.personalize.model.DescribeSolutionRequest;
   import software.amazon.awssdk.services.personalize.model.CreateSolutionVersionRequest;
   import software.amazon.awssdk.services.personalize.model.CreateSolutionVersionResponse;
   import software.amazon.awssdk.services.personalize.model.DescribeSolutionVersionRequest;
   // campaign packages
   import software.amazon.awssdk.services.personalize.model.CreateCampaignRequest;
   import software.amazon.awssdk.services.personalize.model.CreateCampaignResponse;
   // get recommendations packages
   import software.amazon.awssdk.services.personalizeruntime.model.GetRecommendationsRequest;
   import software.amazon.awssdk.services.personalizeruntime.model.GetRecommendationsResponse;
   import software.amazon.awssdk.services.personalizeruntime.model.PredictedItem;
   // Java time utility package
   import java.time.Instant;
   ```

#### Etapa 2: Criar clientes do Amazon Personalize
<a name="getting-started-java-clients"></a>

Depois de adicionar dependências do Amazon Personalize ao seu arquivo pom.xml e importar os pacotes necessários, crie os seguintes clientes do Amazon Personalize:

```
PersonalizeClient personalizeClient = PersonalizeClient.builder()
  .region({{region}})
  .build();

PersonalizeRuntimeClient personalizeRuntimeClient = PersonalizeRuntimeClient.builder() 
  .region({{region}})
  .build();
```

#### Etapa 3: Importar dados
<a name="getting-started-java-import-dataset"></a>

Depois de inicializar seus clientes do Amazon Personalize, importe os dados históricos que você gerou ao concluir [Pré-requisitos de conceitos básicos](gs-prerequisites.md). Para importar os dados históricos para o Amazon Personalize, faça o seguinte:

1.  Salve o esquema Avro a seguir como um arquivo JSON no seu diretório de trabalho. Esse esquema corresponde às colunas no arquivo CSV que você criou ao concluir o [Pré-requisitos de conceitos básicos](gs-prerequisites.md). 

   ```
   {
     "type": "record",
     "name": "Interactions",
     "namespace": "com.amazonaws.personalize.schema",
     "fields": [
         {
             "name": "USER_ID",
             "type": "string"
         },
         {
             "name": "ITEM_ID",
             "type": "string"
         },
         {
             "name": "TIMESTAMP",
             "type": "long"
         }
     ],
     "version": "1.0"
   }
   ```

1. Use o método `createSchema` a seguir para criar um esquema no Amazon Personalize. Envie as seguintes informações como parâmetros: um cliente do serviço Amazon Personalize, o nome do seu esquema e o caminho do arquivo JSON do esquema que você criou na etapa anterior. O método retorna o nome do recurso da Amazon (ARN) do novo esquema. Armazene-o para uso posterior. 

   ```
       public static String createSchema(PersonalizeClient personalizeClient, String schemaName, String filePath) {
   
           String schema = null;
           try {
               schema = new String(Files.readAllBytes(Paths.get(filePath)));
           } catch (IOException e) {
               System.out.println(e.getMessage());
           }
   
           try {
               CreateSchemaRequest createSchemaRequest = CreateSchemaRequest.builder()
                       .name(schemaName)
                       .schema(schema)
                       .build();
   
               String schemaArn = personalizeClient.createSchema(createSchemaRequest).schemaArn();
   
               System.out.println("Schema arn: " + schemaArn);
   
               return schemaArn;
   
           } catch (PersonalizeException e) {
               System.err.println(e.awsErrorDetails().errorMessage());
               System.exit(1);
           }
           return "";
       }
   ```

1. Crie um grupo de conjuntos de dados. Use o método `createDatasetGroup` a seguir para criar um grupo de conjuntos de dados. Envie as seguintes informações como parâmetros: um cliente do serviço Amazon Personalize e o nome do grupo de conjuntos de dados. O método retorna o ARN do seu novo grupo de conjuntos de dados. Armazene-o para uso posterior.

   ```
       public static String createDatasetGroup(PersonalizeClient personalizeClient, String datasetGroupName) {
   
           try {
               CreateDatasetGroupRequest createDatasetGroupRequest = CreateDatasetGroupRequest.builder()
                       .name(datasetGroupName)
                       .build();
               return personalizeClient.createDatasetGroup(createDatasetGroupRequest).datasetGroupArn();
           } catch (PersonalizeException e) {
               System.out.println(e.awsErrorDetails().errorMessage());
           }
           return "";
       }
   ```

1. Crie um conjunto de dados de interações com itens. Use o método `createDataset` a seguir para criar um conjunto de dados de interações com itens. Envie as seguintes informações como parâmetros: um cliente do serviço Amazon Personalize, o nome do seu conjunto de dados, o ARN do seu esquema, o ARN do seu grupo de conjuntos de dados e `Interactions` para o tipo de conjunto de dados. O método retorna o ARN do seu novo conjunto de dados. Armazene-o para uso posterior.

   ```
       public static String createDataset(PersonalizeClient personalizeClient,
               String datasetName,
               String datasetGroupArn,
               String datasetType,
               String schemaArn) {
           try {
               CreateDatasetRequest request = CreateDatasetRequest.builder()
                       .name(datasetName)
                       .datasetGroupArn(datasetGroupArn)
                       .datasetType(datasetType)
                       .schemaArn(schemaArn)
                       .build();
   
               String datasetArn = personalizeClient.createDataset(request)
                       .datasetArn();
               System.out.println("Dataset " + datasetName + " created.");
               return datasetArn;
   
           } catch (PersonalizeException e) {
               System.err.println(e.awsErrorDetails().errorMessage());
               System.exit(1);
           }
           return "";
       }
   ```

1. Importe seus dados com um trabalho de importação do conjunto de dados. Use o método `createPersonalizeDatasetImportJob` a seguir para criar um trabalho de importação de conjuntos de dados. 

   Passe o seguinte como parâmetros: um cliente de serviço do Amazon Personalize, um nome para o trabalho, o ARN do seu conjunto de dados de interações com itens, o caminho do bucket do Amazon S3 (`s3://{{bucket name}}/{{folder name}}/ratings.csv`) onde você armazenou os dados de treinamento e o ARN do seu perfil de serviço (você criou esse perfil como parte dos [Pré-requisitos de conceitos básicos](gs-prerequisites.md)). O método retorna o ARN do trabalho de importação do seu conjunto de dados. Você também pode guardá-lo para uso posterior. 

   ```
       public static String createPersonalizeDatasetImportJob(PersonalizeClient personalizeClient,
               String jobName,
               String datasetArn,
               String s3BucketPath,
               String roleArn) {
   
           long waitInMilliseconds = 60 * 1000;
           String status;
           String datasetImportJobArn;
   
           try {
               DataSource importDataSource = DataSource.builder()
                       .dataLocation(s3BucketPath)
                       .build();
   
               CreateDatasetImportJobRequest createDatasetImportJobRequest = CreateDatasetImportJobRequest.builder()
                       .datasetArn(datasetArn)
                       .dataSource(importDataSource)
                       .jobName(jobName)
                       .roleArn(roleArn)
                       .build();
   
               datasetImportJobArn = personalizeClient.createDatasetImportJob(createDatasetImportJobRequest)
                       .datasetImportJobArn();
               DescribeDatasetImportJobRequest describeDatasetImportJobRequest = DescribeDatasetImportJobRequest.builder()
                       .datasetImportJobArn(datasetImportJobArn)
                       .build();
   
               long maxTime = Instant.now().getEpochSecond() + 3 * 60 * 60;
   
               while (Instant.now().getEpochSecond() < maxTime) {
   
                   DatasetImportJob datasetImportJob = personalizeClient
                           .describeDatasetImportJob(describeDatasetImportJobRequest)
                           .datasetImportJob();
   
                   status = datasetImportJob.status();
                   System.out.println("Dataset import 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 datasetImportJobArn;
   
           } catch (PersonalizeException e) {
               System.out.println(e.awsErrorDetails().errorMessage());
           }
           return "";
       }
   ```

#### Etapa 4: Criar uma solução
<a name="getting-started-java-create-solution"></a>

Depois de importar os dados, crie uma solução e uma versão da solução conforme mostrado a seguir. A *solução* inclui as configurações para treinar um modelo, e uma *versão da solução* é um modelo treinado. 

1. Crie uma nova solução com o método `createPersonalizeSolution` a seguir. Envie as seguintes informações como parâmetros: um cliente do serviço Amazon Personalize, o nome do recurso da Amazon (ARN) dos seus grupos de conjuntos de dados, um nome para a solução e o ARN da fórmula User-Personalization-v2 (`arn:aws:personalize:::recipe/aws-user-personalization-v2`). O método retorna o ARN para sua nova solução. Armazene-o para uso posterior. 

   ```
       public static String createPersonalizeSolution(PersonalizeClient personalizeClient,
               String datasetGroupArn,
               String solutionName,
               String recipeArn) {
   
           try {
               CreateSolutionRequest solutionRequest = CreateSolutionRequest.builder()
                       .name(solutionName)
                       .datasetGroupArn(datasetGroupArn)
                       .recipeArn(recipeArn)
                       .build();
   
               CreateSolutionResponse solutionResponse = personalizeClient.createSolution(solutionRequest);
               return solutionResponse.solutionArn();
   
           } catch (PersonalizeException e) {
               System.err.println(e.awsErrorDetails().errorMessage());
               System.exit(1);
           }
           return "";
       }
   ```

1. Crie uma versão da solução com o método `createPersonalizeSolutionVersion` a seguir. Envie como parâmetro o ARN da solução na etapa anterior. O código a seguir primeiro verifica se sua solução está pronta e, em seguida, cria uma versão da solução. Durante o treinamento, o código usa a operação [DescribeSolutionVersion](API_DescribeSolutionVersion.md) para recuperar o status da versão da solução. Quando o treinamento for concluído, o método retornará o ARN da sua nova versão da solução. Armazene-o para uso posterior. 

   ```
       public static String createPersonalizeSolutionVersion(PersonalizeClient personalizeClient, String solutionArn) {
           long maxTime = 0;
           long waitInMilliseconds = 30 * 1000; // 30 seconds
           String solutionStatus = "";
           String solutionVersionStatus = "";
           String solutionVersionArn = "";
   
           try {
               DescribeSolutionRequest describeSolutionRequest = DescribeSolutionRequest.builder()
                       .solutionArn(solutionArn)
                       .build();
   
               maxTime = Instant.now().getEpochSecond() + 3 * 60 * 60;
   
               // Wait until solution is active.
               while (Instant.now().getEpochSecond() < maxTime) {
   
                   solutionStatus = personalizeClient.describeSolution(describeSolutionRequest).solution().status();
                   System.out.println("Solution status: " + solutionStatus);
   
                   if (solutionStatus.equals("ACTIVE") || solutionStatus.equals("CREATE FAILED")) {
                       break;
                   }
                   try {
                       Thread.sleep(waitInMilliseconds);
                   } catch (InterruptedException e) {
                       System.out.println(e.getMessage());
                   }
               }
   
               if (solutionStatus.equals("ACTIVE")) {
   
                   CreateSolutionVersionRequest createSolutionVersionRequest = CreateSolutionVersionRequest.builder()
                           .solutionArn(solutionArn)
                           .build();
   
                   CreateSolutionVersionResponse createSolutionVersionResponse = personalizeClient
                           .createSolutionVersion(createSolutionVersionRequest);
                   solutionVersionArn = createSolutionVersionResponse.solutionVersionArn();
   
                   System.out.println("Solution version ARN: " + solutionVersionArn);
   
                   DescribeSolutionVersionRequest describeSolutionVersionRequest = DescribeSolutionVersionRequest.builder()
                           .solutionVersionArn(solutionVersionArn)
                           .build();
   
                   while (Instant.now().getEpochSecond() < maxTime) {
   
                       solutionVersionStatus = personalizeClient.describeSolutionVersion(describeSolutionVersionRequest)
                               .solutionVersion().status();
                       System.out.println("Solution version status: " + solutionVersionStatus);
   
                       if (solutionVersionStatus.equals("ACTIVE") || solutionVersionStatus.equals("CREATE FAILED")) {
                           break;
                       }
                       try {
                           Thread.sleep(waitInMilliseconds);
                       } catch (InterruptedException e) {
                           System.out.println(e.getMessage());
                       }
                   }
                   return solutionVersionArn;
               }
           } catch (PersonalizeException e) {
               System.err.println(e.awsErrorDetails().errorMessage());
               System.exit(1);
           }
           return "";
       }
   ```

Para obter mais informações, consulte [Criar uma versão da solução manualmente](creating-a-solution-version.md). Depois de criar uma versão da solução, avalie o desempenho dela antes de prosseguir. Para obter mais informações, consulte [Avaliar uma versão da solução do Amazon Personalize com métricas](working-with-training-metrics.md).

#### Etapa 5: Criar uma campanha
<a name="getting-started-java-deploy-solution"></a>

Depois de treinar e avaliar sua versão da solução, você poderá implantá-la com uma campanha do Amazon Personalize. Use o método `createPersonalCampaign` a seguir para implantar uma versão da solução. Envie as seguintes informações como parâmetros: um cliente do serviço Amazon Personalize, o nome do recurso da Amazon (ARN) da versão da solução que você criou na etapa anterior e um nome para a campanha. O método retorna o ARN da sua nova campanha. Armazene-o para uso posterior.

```
public static String createPersonalCompaign(PersonalizeClient personalizeClient, String solutionVersionArn, String name) {

    try {
        CreateCampaignRequest createCampaignRequest = CreateCampaignRequest.builder()
            .minProvisionedTPS(1)
            .solutionVersionArn(solutionVersionArn)
            .name(name)
            .build();

        CreateCampaignResponse campaignResponse = personalizeClient.createCampaign(createCampaignRequest);
        System.out.println("The campaign ARN is "+campaignResponse.campaignArn());
        return campaignResponse.campaignArn();

    } catch (PersonalizeException e) {
        System.err.println(e.awsErrorDetails().errorMessage());
        System.exit(1);
    }
}
```

Para obter mais informações sobre as campanhas do Amazon Personalize, consulte [Você pode implantar uma versão da solução do Amazon Personalize com uma campanha.Criar uma campanha](campaigns.md).

#### Etapa 6: Obter recomendações
<a name="getting-started-java-get-recommendations"></a>

Depois de criar uma campanha, você pode usá-la para obter recomendações. Use o método `getRecs` a seguir para obter recomendações para um usuário. Envie como parâmetros um cliente do runtime do Amazon Personalize, um nome do recurso da Amazon (ARN) da campanha que você criou na etapa anterior e um ID do usuário (por exemplo, `123`) dos dados históricos que importou. O método exibe a lista de itens recomendados na tela.

```
    public static void getRecs(PersonalizeRuntimeClient personalizeRuntimeClient, String campaignArn, String userId) {

        try {
            GetRecommendationsRequest recommendationsRequest = GetRecommendationsRequest.builder()
                    .campaignArn(campaignArn)
                    .numResults(20)
                    .userId(userId)
                    .build();

            GetRecommendationsResponse recommendationsResponse = personalizeRuntimeClient
                    .getRecommendations(recommendationsRequest);
            List<PredictedItem> items = recommendationsResponse.itemList();
            for (PredictedItem item : items) {
                System.out.println("Item Id is : " + item.itemId());
                System.out.println("Item score is : " + item.score());
            }

        } catch (AwsServiceException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
    }
```

## Projeto completo do Amazon Personalize
<a name="gs-java-example"></a>

Para um projeto completo que mostra como concluir o fluxo de trabalho do Amazon Personalize com o SDK for Java 2.x, consulte [Amazon-Personalize-Java-App](https://github.com/seashman/Amazon-Personalize-Java-App) no GitHub. Esse projeto inclui o treinamento de várias versões da solução com fórmulas diferentes e o registro de eventos com a operação PutEvents.

 Para ver exemplos adicionais, consulte o código encontrado na pasta [personalize](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javav2/example_code/personalize/src/main/java/com/example/personalize) do repositório de exemplos do SDK da AWS.