Introdução (SDKpara Java 2.x) - Amazon Personalize
Pré-requisitosProjeto completo do Amazon Personalize

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

Introdução (SDKpara Java 2.x)

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

Ao terminar o exercício de introdução, para evitar cobranças desnecessárias, exclua os recursos que você criou. Para obter mais informações, consulte Requisitos para excluir recursos do Amazon Personalize.

Para obter mais exemplos, consulte Projeto completo do Amazon Personalize.

Pré-requisitos

Este tutorial tem os seguintes pré-requisitos:

Tutorial

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

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>

  2. 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;

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

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

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

    {
  "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"
}

  2. Use o método createSchema a seguir para criar um esquema no Amazon Personalize. Passe o seguinte como parâmetros: um cliente do serviço Amazon Personalize, o nome do seu esquema e o caminho do arquivo do esquema JSON que você criou na etapa anterior. O método retorna o Amazon Resource Name (ARN) do seu 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 "";
    }

  3. 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 "";
    }

  4. 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. Passe o seguinte como parâmetros: um cliente do serviço Amazon Personalize, o nome do seu conjunto de dados, seu esquema, seu grupo de conjuntos de ARN dados e Interactions o tipo de conjunto de ARN 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 "";
    }

  5. 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 do serviço Amazon Personalize, um nome para o trabalho, seus conjuntos de dados de interações com o ItemARN, o caminho do bucket do Amazon S3 (s3://bucket name/folder name/ratings.csv) onde você armazenou os dados de treinamento e sua função de serviço ARN (você criou essa função como parte da). Pré-requisitos de conceitos básicos O método retorna o trabalho ARN 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 "";
    }

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. Passe o seguinte como parâmetros: um cliente do serviço Amazon Personalize, seu conjunto de dados agrupa Amazon Resource Name (ARN), um nome para a solução e a receita do ARN User-Personalization-v2 (). arn:aws:personalize:::recipe/aws-user-personalization-v2 O método retorna ARN 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 "";
    }

  2. Crie uma versão da solução com o método createPersonalizeSolutionVersion a seguir. Passe 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 para recuperar o status da versão da solução. Quando o treinamento for concluído, o método retornará a versão ARN da sua nova 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 Criando manualmente uma versão da solução. Depois de criar uma versão da solução, avalie o desempenho dela antes de prosseguir. Para obter mais informações, consulte Avaliação de uma versão da solução Amazon Personalize com métricas.

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. Passe o seguinte como parâmetros: um cliente do serviço Amazon Personalize, o Amazon Resource Name (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 Implantação de uma versão da solução Amazon Personalize com uma campanha.

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. Passe como parâmetros um cliente de tempo de execução do Amazon Personalize, o Amazon Resource Name (ARN) da campanha que você criou na etapa anterior e um ID de usuário (por exemplo,123) dos dados históricos que você 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

Para um all-in-one projeto que mostra como concluir o fluxo de trabalho do Amazon Personalize com o SDK for Java 2.x, consulte o aplicativo Amazon-Personalize-Java em. GitHub Esse projeto inclui o treinamento de várias versões da solução com receitas diferentes e a gravação de eventos com a PutEvents operação.

Para obter exemplos adicionais, consulte o código encontrado na pasta de personalização do AWS SDKrepositório de exemplos.