Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Guida introduttiva a un gruppo di set di dati di dominio (SDK for Java 2.x)
<a name="domain-getting-started-java"></a>

Questo tutorial mostra come utilizzare l'SDK for Java 2.x per creare un gruppo di set di dati di dominio per il dominio VIDEO\_ON\_DEMAND. *In questo tutorial, crei un programma di raccomandazione per il caso d'uso Top pick for you.*

Al termine dell'esercizio introduttivo, per evitare di incorrere in addebiti inutili, elimina le risorse che hai creato. Per ulteriori informazioni, consulta [Requisiti per l'eliminazione delle risorse Amazon Personalize](deleting-resources.md). 

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

Di seguito sono riportati i passaggi preliminari per il completamento di questo tutorial:
+ Completa il [Prerequisiti per iniziare](gs-prerequisites.md) modulo per configurare le autorizzazioni richieste e creare i dati di addestramento. Se hai completato anche il[Guida introduttiva a un gruppo di set di dati di dominio (console)](getting-started-console-domain.md), puoi riutilizzare gli stessi dati di origine. Se utilizzi i tuoi dati di origine, assicurati che i dati siano formattati come nei prerequisiti.
+ *Configura l'ambiente AWS e le credenziali SDK for Java 2.x come specificato nella AWS SDK for Java 2.x procedura di [configurazione della Guida per AWS SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html) gli sviluppatori.* 

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

Nei passaggi seguenti, configuri il tuo progetto per utilizzare i pacchetti Amazon Personalize e creare Amazon Personalize SDK per i client Java 2.x. Quindi importi i dati, crei un programma di raccomandazione per lo use case *Top pick for you* e ricevi consigli.

### Passaggio 1: configura il progetto per utilizzare i pacchetti Amazon Personalize
<a name="domain-gs-java-set-up-project"></a>

Dopo aver completato i prerequisiti, aggiungi le dipendenze di Amazon Personalize al file pom.xml e importa i pacchetti Amazon Personalize. 

1.  Aggiungi le seguenti dipendenze al tuo file pom.xml. I numeri di versione più recenti possono essere diversi dal codice di esempio. 

   ```
   <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.  Aggiungi le seguenti istruzioni di importazione al tuo progetto. 

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

### Fase 2: Creare clienti Amazon Personalize
<a name="domain-gs-java-clients"></a>

Dopo aver aggiunto le dipendenze di Amazon Personalize al file pom.xml e importato i pacchetti richiesti, crea i seguenti client Amazon Personalize:

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

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

### Fase 3: Importazione dei dati
<a name="domain-gs-java-import-dataset"></a>

Dopo aver inizializzato i tuoi clienti Amazon Personalize, importa i dati storici che hai creato quando hai completato il. [Prerequisiti per iniziare](gs-prerequisites.md) Per importare dati storici in Amazon Personalize, procedi come segue:

1.  Salva il seguente schema Avro come file JSON nella tua directory di lavoro. Questo schema corrisponde alle colonne del file CSV che hai creato quando hai completato il. [Creazione dei dati di addestramento (gruppo di set di dati del 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. Utilizza il seguente `createDomainSchema` metodo per creare uno schema di dominio in Amazon Personalize. Passa i seguenti parametri come parametri: un client del servizio Amazon Personalize, il nome dello schema, `VIDEO_ON_DEMAND` del dominio e il percorso del file JSON dello schema creato nel passaggio precedente. Il metodo restituisce l'Amazon Resource Name (ARN) del nuovo schema. Va archiviato per essere utilizzato in un secondo momento. 

   ```
       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. Creazione di un gruppo di set di dati Usa il seguente `createDomainDatasetGroup` metodo per creare un gruppo di set di dati di dominio. Passa i seguenti parametri come parametri: un client del servizio Amazon Personalize, un nome per il gruppo di set di dati e un pass `VIDEO_ON_DEMAND` per il dominio. Il metodo restituisce l'ARN del nuovo gruppo di set di dati. Va archiviato per essere utilizzato in un secondo momento.

   ```
       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. Crea un set di dati sulle interazioni tra oggetti. Usa il seguente `createDataset` metodo per creare un set di dati sulle interazioni degli elementi. Passa i seguenti parametri come parametri: un client di servizio Amazon Personalize, il nome del set di dati, l'ARN dello schema, l'ARN del gruppo di set di dati e il tipo di set di dati. `Interactions` Il metodo restituisce l'ARN del nuovo set di dati. Va archiviato per essere utilizzato in un secondo momento.

   ```
       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. Importa i tuoi dati con un processo di importazione del set di dati. Utilizzate il seguente `createPersonalizeDatasetImportJob` metodo per creare un processo di importazione del set di dati. 

   Passa i seguenti parametri come parametri: un client del servizio Amazon Personalize, un nome per il lavoro e l'ARN del set di dati Interactions. Passa il bucket path di Amazon S3 (`s3://{{bucket name}}/{{folder name}}/ratings.csv`) in cui hai archiviato i dati di formazione e l'ARN del tuo ruolo di servizio. Hai creato questo ruolo come parte di. [Prerequisiti per iniziare](gs-prerequisites.md) Il metodo restituisce l'ARN del processo di importazione del set di dati. Facoltativamente, memorizzalo per un uso successivo. 

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

### Fase 4: Creare un programma di raccomandazione
<a name="domain-gs-create-recommender"></a>

Una volta completato il processo di importazione del set di dati, sei pronto per creare un programma di raccomandazione. Utilizzate il seguente `createRecommender` metodo per creare un programma di raccomandazione. Passa i seguenti parametri come parametri: un client del servizio Amazon Personalize, un nome per il consulente, l'Amazon Resource Name (ARN) del gruppo di dati e l'ARN per la ricetta. `arn:aws:personalize:::recipe/aws-vod-top-picks` Il metodo restituisce l'ARN del nuovo consulente. Va archiviato per essere utilizzato in un secondo momento.

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

### Passaggio 5: Ottieni consigli
<a name="domain-gs-java-get-recommendations"></a>

Dopo aver creato un programma di raccomandazione, lo usi per ricevere consigli. Utilizzate il seguente `getRecs` metodo per ottenere consigli per un utente. Passa come parametri un client di runtime Amazon Personalize, l'Amazon Resource Name (ARN) del programma di raccomandazione che hai creato nel passaggio precedente e un ID utente (ad esempio,). `123` Il metodo stampa l'elenco degli elementi consigliati sullo schermo. 

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