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 a un grupo de conjuntos de datos de dominio (SDK para Java 2.x)
<a name="domain-getting-started-java"></a>

En este tutorial, se muestra cómo utilizar el SDK para Java 2.x para crear un grupo de conjuntos de datos de dominio para el dominio VIDEO\_ON\_DEMAND. En este tutorial, se crea un recomendador para el caso de uso *Mejores opciones*.

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

## Requisitos previos
<a name="domain-gs-java-prerequisites"></a>

Los siguientes son pasos previos para completar este tutorial:
+ Complete los [Requisitos previos para los ejercicios de introducción](gs-prerequisites.md) para configurar los permisos necesarios y crear los datos de entrenamiento. Si también completó [Introducción a un grupo de conjuntos de datos de dominio (consola)](getting-started-console-domain.md), puede reutilizar los mismos datos de origen. Si utiliza sus propios datos de origen, asegúrese de que tienen el formato que se indica en los requisitos previos.
+ Configure el SDK para Java 2.x y las credenciales de AWS tal y como se especifica en el procedimiento [Configuración del AWS SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html) de la *Guía para desarrolladores de AWS SDK for Java 2.x*. 

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

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, se importan los datos, se crea un recomendador para el caso de uso *Mejores opciones* y se obtienen recomendaciones.

### Paso 1: Configurar el proyecto para utilizar paquetes de Amazon Personalize
<a name="domain-gs-java-set-up-project"></a>

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>
   ```

1.  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;
   // recommender packages
   import software.amazon.awssdk.services.personalize.model.CreateRecommenderRequest;
   import software.amazon.awssdk.services.personalize.model.CreateRecommenderResponse;
   import software.amazon.awssdk.services.personalize.model.DescribeRecommenderRequest;
   // 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;
   ```

### Paso 2: Crear clientes de Amazon Personalize
<a name="domain-gs-java-clients"></a>

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

### Paso 3: Importar datos
<a name="domain-gs-java-import-dataset"></a>

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](gs-prerequisites.md). 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 [Creación de los datos de entrenamiento (grupo de conjuntos de datos de dominio)](gs-prerequisites.md#gs-data-prep-domain). 

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

1. Utilice el siguiente método `createDomainSchema` para crear un esquema de dominio en Amazon Personalize. Pase lo siguiente como parámetros: un cliente del servicio de Amazon Personalize, el nombre del esquema, `VIDEO_ON_DEMAND` para el dominio y la ruta del archivo para el esquema JSON 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 createDomainSchema(PersonalizeClient personalizeClient, String schemaName, String domain,
               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)
                       .domain(domain)
                       .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. Crear un grupo de conjuntos de datos. Utilice el siguiente método `createDomainDatasetGroup` para crear un grupo de conjuntos de datos de dominio. Pase lo siguiente como parámetros: un cliente del servicio de Amazon Personalize, un nombre para el grupo de conjuntos de datos, y pase `VIDEO_ON_DEMAND` para el dominio. El método devuelve el ARN de su nuevo grupo de conjuntos de datos. Guárdelo para usarlo después.

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

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

1. 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 y el ARN de su conjunto de datos de interacciones. Pase la ruta del bucket de Amazon S3 (`s3://{{bucket name}}/{{folder name}}/ratings.csv`) donde almacenó los datos de entrenamiento y el ARN de su rol de servicio. Creó este rol como parte de los [Requisitos previos para los ejercicios de introducción](gs-prerequisites.md). 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 "";
       }
   ```

### Paso 4: Crear un generador de recomendaciones
<a name="domain-gs-create-recommender"></a>

Una vez finalizado el trabajo de importación del conjunto de datos, estará listo para crear un generador de recomendaciones. Use el siguiente método `createRecommender` para crear un generador de recomendaciones. Pase lo siguiente como parámetros: un cliente de servicio de Amazon Personalize, un nombre para el generador de recomendaciones, el nombre de recurso de Amazon (ARN) de su grupo de conjuntos de datos, y `arn:aws:personalize:::recipe/aws-vod-top-picks` para el ARN de la receta. El método devuelve el ARN de su nuevo generador de recomendaciones. Guárdelo para usarlo después.

```
    public static String createRecommender(PersonalizeClient personalizeClient,
            String name,
            String datasetGroupArn,
            String recipeArn) {

        long maxTime = 0;
        long waitInMilliseconds = 30 * 1000; // 30 seconds
        String recommenderStatus = "";

        try {
            CreateRecommenderRequest createRecommenderRequest = CreateRecommenderRequest.builder()
                    .datasetGroupArn(datasetGroupArn)
                    .name(name)
                    .recipeArn(recipeArn)
                    .build();

            CreateRecommenderResponse recommenderResponse = personalizeClient
                    .createRecommender(createRecommenderRequest);
            String recommenderArn = recommenderResponse.recommenderArn();
            System.out.println("The recommender ARN is " + recommenderArn);

            DescribeRecommenderRequest describeRecommenderRequest = DescribeRecommenderRequest.builder()
                    .recommenderArn(recommenderArn)
                    .build();

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

            while (Instant.now().getEpochSecond() < maxTime) {

                recommenderStatus = personalizeClient.describeRecommender(describeRecommenderRequest).recommender()
                        .status();
                System.out.println("Recommender status: " + recommenderStatus);

                if (recommenderStatus.equals("ACTIVE") || recommenderStatus.equals("CREATE FAILED")) {
                    break;
                }
                try {
                    Thread.sleep(waitInMilliseconds);
                } catch (InterruptedException e) {
                    System.out.println(e.getMessage());
                }
            }
            return recommenderArn;

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

### Paso 5: Obtener recomendaciones
<a name="domain-gs-java-get-recommendations"></a>

Después de crear un generador de recomendaciones, úselo 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) del generador de recomendaciones que ha creado en el paso anterior y un ID de usuario (por ejemplo, `123`). El método imprime la lista de elementos recomendados en la pantalla. 

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

        try {
            GetRecommendationsRequest recommendationsRequest = GetRecommendationsRequest.builder()
                    .recommenderArn(recommenderArn)
                    .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);
        }
    }
```