Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

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

Tutorial ini menunjukkan kepada Anda cara menyelesaikan alur kerja Amazon Personalize dari awal hingga akhir dengan. AWS SDK for Java 2.x

Saat Anda menyelesaikan latihan memulai, untuk menghindari biaya yang tidak perlu, hapus sumber daya yang Anda buat. Untuk informasi selengkapnya, lihat [Persyaratan untuk menghapus sumber daya Amazon Personalize](deleting-resources.md). 

Untuk contoh lainnya, lihat [Selesaikan proyek Amazon Personalize](#gs-java-example).

**Topics**
+ [Prasyarat](#gs-java-prerequisites)
+ [Selesaikan proyek Amazon Personalize](#gs-java-example)

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

Berikut ini adalah langkah-langkah prasyarat untuk menyelesaikan tutorial ini:
+ Selesaikan[Memulai prasyarat](gs-prerequisites.md), untuk mengatur izin yang diperlukan dan membuat data pelatihan. Anda dapat menggunakan data sumber yang sama yang digunakan dalam [Memulai (konsol)](getting-started-console.md) atau [Memulai (AWS CLI)](getting-started-cli.md) latihan. Jika Anda menggunakan data sumber Anda sendiri, pastikan bahwa data Anda diformat seperti dalam prasyarat.
+ *Siapkan lingkungan SDK for Java 2.x AWS dan kredensialnya seperti yang ditentukan dalam [Menyiapkan prosedur di Panduan AWS SDK for Java 2.x Pengembang](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html).AWS SDK for Java 2.x * 

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

Dalam langkah-langkah berikut, Anda menyiapkan project untuk menggunakan paket Amazon Personalize dan membuat Amazon Personalize SDK for Java 2.x client. Kemudian Anda mengimpor data, membuat dan menerapkan versi solusi dengan kampanye, dan mendapatkan rekomendasi.

#### Langkah 1: Siapkan project Anda untuk menggunakan paket Amazon Personalize
<a name="gs-java-set-up-project"></a>

Setelah menyelesaikan prasyarat, tambahkan dependensi Amazon Personalize ke file pom.xml dan impor paket Amazon Personalize. 

1.  Tambahkan dependensi berikut ke file pom.xml Anda. Nomor versi terbaru mungkin berbeda dari kode contoh. 

   ```
   <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.  Tambahkan pernyataan impor berikut ke proyek Anda. 

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

#### Langkah 2: Buat Amazon Personalisasi klien
<a name="getting-started-java-clients"></a>

Setelah menambahkan dependensi Amazon Personalize ke file pom.xml dan mengimpor paket yang diperlukan, buat klien Amazon Personalize berikut:

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

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

#### Langkah 3: Impor data
<a name="getting-started-java-import-dataset"></a>

Setelah Anda menginisialisasi klien Amazon Personalize, impor data historis yang Anda buat saat Anda menyelesaikan. [Memulai prasyarat](gs-prerequisites.md) Untuk mengimpor data historis ke Amazon Personalize, lakukan hal berikut:

1.  Simpan skema Avro berikut sebagai file JSON di direktori kerja Anda. Skema ini cocok dengan kolom dalam file CSV yang Anda buat saat Anda menyelesaikan. [Memulai prasyarat](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. Gunakan `createSchema` metode berikut untuk membuat skema di Amazon Personalize. Teruskan yang berikut ini sebagai parameter: klien layanan Amazon Personalize, nama untuk skema Anda, dan jalur file untuk file JSON skema yang Anda buat pada langkah sebelumnya. Metode ini mengembalikan Amazon Resource Name (ARN) skema baru Anda. Simpan untuk digunakan nanti. 

   ```
       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. Buat grup dataset. Gunakan `createDatasetGroup` metode berikut untuk membuat grup dataset. Teruskan yang berikut ini sebagai parameter: klien layanan Amazon Personalize dan nama untuk grup kumpulan data. Metode mengembalikan ARN dari grup dataset baru Anda. Simpan untuk digunakan nanti.

   ```
       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. Buat kumpulan data interaksi Item. Gunakan `createDataset` metode berikut untuk membuat kumpulan data interaksi Item. Teruskan yang berikut ini sebagai parameter: klien layanan Amazon Personalize, nama untuk kumpulan data Anda, ARN skema Anda, ARN grup kumpulan data Anda, dan untuk jenis kumpulan data. `Interactions` Metode mengembalikan ARN dari dataset baru Anda. Simpan untuk digunakan nanti.

   ```
       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. Impor data Anda dengan pekerjaan impor dataset. Gunakan `createPersonalizeDatasetImportJob` metode berikut untuk membuat pekerjaan impor dataset. 

   Teruskan parameter berikut ini sebagai parameter: klien layanan Amazon Personalisasi, nama untuk pekerjaan, ARN kumpulan data interaksi Item, jalur bucket Amazon S3 (`s3://{{bucket name}}/{{folder name}}/ratings.csv`) tempat Anda menyimpan data pelatihan, dan ARN peran layanan Anda (Anda membuat peran ini sebagai bagian dari). [Memulai prasyarat](gs-prerequisites.md) Metode mengembalikan ARN dari pekerjaan impor dataset Anda. Secara opsional simpan untuk digunakan nanti. 

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

#### Langkah 4: Buat solusi
<a name="getting-started-java-create-solution"></a>

Setelah mengimpor data, Anda membuat solusi dan versi solusi sebagai berikut. *Solusinya* berisi konfigurasi untuk melatih model dan *versi solusi* adalah model terlatih. 

1. Buat solusi baru dengan `createPersonalizeSolution` metode berikut. Teruskan yang berikut ini sebagai parameter: klien layanan Amazon Personalize, kumpulan data Anda mengelompokkan Amazon Resource Name (ARN), nama untuk solusi, dan ARN untuk resep 2 (). User-Personalization-v `arn:aws:personalize:::recipe/aws-user-personalization-v2` Metode mengembalikan ARN solusi baru Anda. Simpan untuk digunakan nanti. 

   ```
       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. Buat versi solusi dengan `createPersonalizeSolutionVersion` metode berikut. Lulus sebagai parameter ARN dari solusi langkah sebelumnya. Kode berikut pertama-tama memeriksa untuk melihat apakah solusi Anda sudah siap dan kemudian membuat versi solusi. Selama pelatihan, kode menggunakan [DescribeSolutionVersion](API_DescribeSolutionVersion.md) operasi untuk mengambil status versi solusi. Saat pelatihan selesai, metode mengembalikan ARN versi solusi baru Anda. Simpan untuk digunakan nanti. 

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

Untuk informasi selengkapnya, lihat [Membuat versi solusi secara manual](creating-a-solution-version.md). Saat Anda membuat versi solusi, Anda dapat mengevaluasi kinerjanya sebelum melanjutkan. Untuk informasi selengkapnya, lihat [Mengevaluasi versi solusi Amazon Personalize dengan metrik](working-with-training-metrics.md).

#### Langkah 5: Buat kampanye
<a name="getting-started-java-deploy-solution"></a>

Setelah Anda melatih dan mengevaluasi versi solusi Anda, terapkan dengan kampanye Amazon Personalize. Gunakan `createPersonalCampaign` metode berikut untuk menerapkan versi solusi. Teruskan yang berikut ini sebagai parameter: klien layanan Amazon Personalisasi, Nama Sumber Daya Amazon (ARN) dari versi solusi yang Anda buat pada langkah sebelumnya, dan nama untuk kampanye. Metode mengembalikan ARN kampanye baru Anda. Simpan untuk digunakan nanti.

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

Untuk informasi selengkapnya tentang kampanye Amazon Personalisasi, lihat. [Menerapkan versi solusi Amazon Personalize dengan kampanyeMembuat kampanye](campaigns.md)

#### Langkah 6: Dapatkan rekomendasi
<a name="getting-started-java-get-recommendations"></a>

Setelah Anda membuat kampanye, Anda menggunakannya untuk mendapatkan rekomendasi. Gunakan `getRecs` metode berikut untuk mendapatkan rekomendasi bagi pengguna. Teruskan sebagai parameter klien runtime Amazon Personalisasi, Nama Sumber Daya Amazon (ARN) kampanye yang Anda buat pada langkah sebelumnya, dan ID pengguna (misalnya,`123`) dari data historis yang Anda impor. Metode ini mencetak daftar item yang direkomendasikan ke layar.

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

## Selesaikan proyek Amazon Personalize
<a name="gs-java-example"></a>

[Untuk all-in-one project yang menunjukkan cara menyelesaikan alur kerja Amazon Personalize dengan SDK for Java 2.x, lihat Amazon-Personalize-Java-App aktif.](https://github.com/seashman/Amazon-Personalize-Java-App) GitHub Proyek ini mencakup pelatihan beberapa versi solusi dengan resep yang berbeda, dan merekam acara dengan PutEvents operasi.

 Untuk contoh tambahan, lihat kode yang ditemukan di folder [personalisasi repositori](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javav2/example_code/personalize/src/main/java/com/example/personalize) contoh AWS SDK.