Introducción (SDK para Java 2.x) - Amazon Personalize
Requisitos previosProyecto completo de Amazon Personalize

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Introducción (SDK para Java 2.x)

Este tutorial le muestra cómo completar el flujo de trabajo de Amazon Personalize de principio a fin con el AWS SDK for Java 2.x.

Cuando termine el ejercicio de introducción, para evitar incurrir en cargos innecesarios, elimine los recursos que ha creado. Para obtener más información, consulte Requisitos para eliminar recursos de Amazon Personalize.

Para obtener más ejemplos, consulte Proyecto completo de Amazon Personalize.

Requisitos previos

Los siguientes son pasos previos para completar este tutorial:

Tutorial

En los siguientes pasos, configurará su proyecto para que utilice los paquetes de Amazon Personalize y cree el SDK de Amazon Personalize para clientes de Java 2.x. A continuación, importará los datos, creará e implementará una versión de la solución con una campaña, y obtendrá recomendaciones.

Tras completar los requisitos previos, añada las dependencias de Amazon Personalize a su archivo pom.xml e importe los paquetes de Amazon Personalize.

  1. Añada las siguientes dependencias a su archivo pom.xml. Los números de versión más recientes pueden ser diferentes a los del código de ejemplo. 

    <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. Añada las siguientes instrucciones de importación al proyecto. 

    // 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;

Tras añadir las dependencias de Amazon Personalize al archivo pom.xml e importar los paquetes necesarios, cree los siguientes clientes de Amazon Personalize:

PersonalizeClient personalizeClient = PersonalizeClient.builder()
  .region(region)
  .build();

PersonalizeRuntimeClient personalizeRuntimeClient = PersonalizeRuntimeClient.builder() 
  .region(region)
  .build();

Tras inicializar sus clientes de Amazon Personalize, importe los datos históricos que creó al completar los Requisitos previos para los ejercicios de introducción. Para importar datos históricos en Amazon Personalize, haga lo siguiente:

  1. Guarde el siguiente esquema de Avro como archivo JSON en su directorio de trabajo. Este esquema coincide con las columnas del archivo CSV que creó al completar el Requisitos previos para los ejercicios de introducción. 

    {
  "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. Utilice el siguiente método createSchema para crear un esquema en Amazon Personalize. Pase lo siguiente como parámetros: un cliente del servicio de Amazon Personalize, el nombre del esquema, la ruta del archivo JSON de esquema que creó en el paso anterior. El método devuelve el nombre de recurso de Amazon (ARN) del esquema nuevo. Guárdelo para usarlo después. 

        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. Crear un grupo de conjuntos de datos. Utilice el siguiente método createDatasetGroup para crear un grupo de conjuntos de datos. Pase como parámetros lo siguiente: un cliente del servicio de Amazon Personalize y el nombre del grupo de conjuntos de datos. El método devuelve el ARN de su nuevo grupo de conjuntos de datos. Guárdelo para usarlo después.

        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. Cree un conjunto de datos de interacciones de elementos. Use el siguiente método createDataset para crear un conjunto de datos de interacciones de elementos. Pase lo siguiente como parámetros: un cliente del servicio de Amazon Personalize, el nombre de su conjunto de datos, el ARN de su esquema, el ARN de su grupo de conjuntos de datos, y Interactions para el tipo de conjunto de datos. El método devuelve el ARN de su nuevo conjunto de datos. Guárdelo para usarlo después.

        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 sus datos con un trabajo de importación de conjuntos de datos. Utilice el siguiente método createPersonalizeDatasetImportJob para crear un trabajo de importación de conjuntos de datos.

    Pase lo siguiente como parámetros: un cliente del servicio de Amazon Personalize, un nombre para el trabajo, el ARN del conjunto de datos de interacciones de elemento, la ruta del bucket de Amazon S3 (s3://bucket name/folder name/ratings.csv) donde ha almacenado los datos de entrenamiento y el ARN del rol de servicio (lo ha creado como parte de los Requisitos previos para los ejercicios de introducción). El método devuelve el ARN de su trabajo de importación de conjuntos de datos. Si lo desea, guárdelo para usarlo más adelante. 

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

Después de importar los datos, cree una solución y una versión de la solución de la siguiente manera. La solución contiene las configuraciones para entrenar un modelo y una versión de la solución es un modelo entrenado.

  1. Cree una nueva solución con el siguiente método createPersonalizeSolution. Pase lo siguiente como parámetros: un cliente de servicio Amazon Personalize, su conjunto de datos agrupa el nombre de recurso de Amazon (ARN), un nombre para la solución y el ARN para la receta User-Personalization-v 2 (). arn:aws:personalize:::recipe/aws-user-personalization-v2 El método devuelve el ARN de su nueva solución. Guárdelo para usarlo después. 

        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. Cree una versión de la solución con el siguiente método createPersonalizeSolutionVersion. Pase como parámetro el ARN de la solución del paso anterior. El siguiente código comprueba primero si la solución está lista y, a continuación, crea una versión de la solución. Durante el entrenamiento, el código utiliza la operación DescribeSolutionVersion para recuperar el estado de la versión de la solución. Una vez finalizado el entrenamiento, el método devuelve el ARN de la nueva versión de su solución. Guárdelo para usarlo después. 

        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 obtener más información, consulte Creación manual de una versión de solución. Al crear una versión de la solución, puede evaluar su rendimiento antes de continuar. Para obtener más información, consulte Evaluación de una versión de solución de Amazon Personalize con métricas.

Después de entrenar y evaluar la versión de su solución, impleméntela con una campaña de Amazon Personalize. Use el siguiente método createPersonalCampaign para implementar una versión de la solución. Pase lo siguiente como parámetros: un cliente del servicio de Amazon Personalize, el nombre de recurso de Amazon (ARN) de la versión de la solución que creó en el paso anterior y un nombre para la campaña. El método devuelve el ARN de la nueva campaña. Guárdelo para usarlo después.

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 obtener más información acerca de las campañas de Amazon Personalize, consulte Implementación de una versión de solución de Amazon Personalize con una campaña.

Después de crear una campaña, puede utilizarla para obtener recomendaciones. Utilice el siguiente método getRecs para obtener recomendaciones para un usuario. Pase como parámetros un cliente de versión ejecutable de Amazon Personalize, el nombre de recurso de Amazon (ARN) de la campaña que ha creado en el paso anterior y un ID de usuario (por ejemplo, 123) a partir de los datos históricos que ha importado. El método imprime la lista de elementos recomendados en la pantalla.

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

Proyecto completo de Amazon Personalize

Para ver un all-in-one proyecto que muestre cómo completar el flujo de trabajo de Amazon Personalize con el SDK para Java 2.x, consulte la aplicación Amazon Personalize-Java en. GitHub Este proyecto incluye la formación de varias versiones de la solución con diferentes fórmulas y la grabación de eventos durante la operación. PutEvents

Para ver más ejemplos, consulte el código que se encuentra en la carpeta de personalización del repositorio de ejemplos del AWS SDK.