翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。

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

このチュートリアルでは、AWS SDK for Java 2.x を使用して Amazon Personalize のワークフローを最初から最後まで完了する方法を示します。

開始方法の演習を完了したら、不要な料金が発生しないように、作成したリソースを削除します。詳細については、「[Amazon Personalize リソースを削除するための要件](deleting-resources.md)」を参照してください。

その他の 例については、「」を参照してください[Amazon Personalize のプロジェクトを完了する](#gs-java-example)

**Topics**
+ [前提条件](#gs-java-prerequisites)
+ [Amazon Personalize のプロジェクトを完了する](#gs-java-example)

## 前提条件
<a name="gs-java-prerequisites"></a>

このチュートリアルを完了するための前提条件となる手順は次のとおりです。
+ [開始方法の前提条件](gs-prerequisites.md) を完了して、必要な権限を設定し、トレーニングデータを作成します。[開始方法 (コンソール)](getting-started-console.md) または [開始方法 (AWS CLI)](getting-started-cli.md) の演習で使用したのと同じソースデータを使用できます。独自のソースデータを使用する場合は、前提条件のようにそのデータがフォーマットされていることを確認します。
+ **「AWS SDK for Java 2.x デベロッパーガイド」の「[AWS SDK for Java 2.x の設定](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html)」手順で指定されているように、SDK for Java 2.x 環境と AWS 認証情報を設定します。

### チュートリアル
<a name="gs-custom-java-tutorial"></a>

次のステップでは、Amazon Personalize パッケージを使用するようにプロジェクトを設定し、Amazon Personalize の SDK for Java 2.x クライアントを作成します。次に、データをインポートし、キャンペーンを含むソリューションバージョンを作成およびデプロイして、レコメンデーションを取得します。

#### ステップ 1: Amazon Personalize のパッケージを使用するようにプロジェクトを設定する
<a name="gs-java-set-up-project"></a>

前提条件を完了したら、Amazon Personalize の依存関係を pom.xml ファイルに追加し、Amazon Personalize のパッケージをインポートします。

1.  次の依存関係を pom.xml ファイルに追加します。最新のバージョン番号は、サンプルコードとは異なる場合があります。

   ```
   <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.  プロジェクトに次のインポートステートメントを追加します。

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

#### ステップ 2: Amazon Personalize のクライアントを作成する
<a name="getting-started-java-clients"></a>

Amazon Personalize の依存関係を pom.xml ファイルに追加し、必要なパッケージをインポートしたて、次の Amazon Personalize のクライアントをインスタンス化します。

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

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

#### ステップ 3: データをインポートする
<a name="getting-started-java-import-dataset"></a>

Amazon Personalize のクライアントを初期化したら、[開始方法の前提条件](gs-prerequisites.md) の完了時に作成した履歴データをインポートします。過去のデータを Amazon Personalize にインポートするには、次の操作を実行します。

1.  次の Avro スキーマを JSON ファイルとして作業ディレクトリに保存します。このスキーマは、[開始方法の前提条件](gs-prerequisites.md) を完了したときに作成した CSV ファイルの列と一致します。

   ```
   {
     "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. 次の `createSchema` メソッドを使用して、Amazon Personalize でスキーマを作成します。パラメータとして、Amazon Personalize のサービスクライアント、スキーマの名前、および前のステップで作成したスキーマ JSON ファイルのファイルパスを渡します。このメソッドは、新しいスキーマの Amazon リソースネーム (ARN) を返します。後で使用するために、これを保存します。

   ```
       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. データセットグループを作成します。次の `createDatasetGroup` メソッドを使用して、データセットグループを作成します。パラメータとして、Amazon Personalize のサービスクライアントとデータセットグループの名前を渡します。このメソッドは、新しいデータセットグループの ARN を返します。後で使用するために、これを保存します。

   ```
       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. アイテムインタラクションデータセットを作成します。次の `createDataset` メソッドを使用して、アイテムインタラクションデータセットを作成します。パラメータとして、Amazon Personalize のサービスクライアント、データセットの名前、スキーマの ARN、データセットグループの ARN、およびデータセットタイプの `Interactions` を渡します。このメソッドは、新しいデータセットの ARN を返します。後で使用するために、これを保存します。

   ```
       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. データセットのインポートジョブを使用してデータをインポートします。次の `createPersonalizeDatasetImportJob` メソッドを使用して、データセットのインポートジョブを作成します。

   パラメータとして、Amazon Personalize のサービスクライアント、ジョブの名前、アイテムインタラクションデータセットの ARN、トレーニングデータを保存した Amazon S3 バケットパス (`s3://{{bucket name}}/{{folder name}}/ratings.csv`)、サービスロールの ARN (「[開始方法の前提条件](gs-prerequisites.md)」で作成したロール) を渡します。このメソッドは、データセットのインポートジョブの ARN を返します。オプションで、後で使用するために保存します。

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

#### ステップ 4: ソリューションを作成する
<a name="getting-started-java-create-solution"></a>

データをインポートしたら、次のようにソリューションとソリューションバージョンを作成します。*ソリューション*にはモデルをトレーニングするための設定が含まれており、*ソリューションバージョン*はトレーニング済みモデルです。

1. 次の `createPersonalizeSolution` メソッドで新しいソリューションを作成します。パラメータとして、Amazon Personalize のサービスクライアント、データセットグループの Amazon リソースネーム (ARN)、ソリューションの名前、および User-Personalization-v2 レシピの ARN (`arn:aws:personalize:::recipe/aws-user-personalization-v2`) を渡します。このメソッドは、新しいソリューションの ARN を返します。後で使用するために、これを保存します。

   ```
       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. 次の `createPersonalizeSolutionVersion` メソッドでソリューションバージョンを作成します。前のステップのソリューションの ARN をパラメータとして渡します。次のコードを実行すると、最初にソリューションの準備ができているかどうかを確認してから、ソリューションバージョンを作成します。トレーニング中、コードは [DescribeSolutionVersion](API_DescribeSolutionVersion.md) 操作を使用してソリューションバージョンのステータスを取得します。トレーニングが完了すると、メソッドは新しいソリューションバージョンの ARN を返します。後で使用するために、これを保存します。

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

詳細については、「[ソリューションバージョンの手動作成](creating-a-solution-version.md)」を参照してください。ソリューションバージョンを作成したら、先に進む前にそのパフォーマンスを評価できます。詳細については、「[メトリクスを使用して Amazon Personalize ソリューションバージョンを評価する](working-with-training-metrics.md)」を参照してください。

#### ステップ 5: キャンペーンを作成する
<a name="getting-started-java-deploy-solution"></a>

ソリューションバージョンをトレーニングして評価した後、Amazon Personalize キャンペーンでそれをデプロイします。次の `createPersonalCampaign` メソッドを使用して、ソリューションバージョンをデプロイします。パラメータとして、Amazon Personalize のサービスクライアント、前のステップで作成したソリューションバージョンの Amazon リソースネーム (ARN)、およびキャンペーンの名前を渡します。このメソッドは、新しいキャンペーンの ARN を返します。後で使用するために、これを保存します。

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

Amazon Personalize のキャンペーンの詳細については、「[キャンペーンを使用して Amazon Personalize のソリューションバージョンをデプロイするキャンペーンの作成](campaigns.md)」を参照してください。

#### ステップ 6: レコメンデーションを取得する
<a name="getting-started-java-get-recommendations"></a>

キャンペーンを作成したら、そのキャンペーンを使用してレコメンデーションを取得します。次の `getRecs` メソッドを使用して、ユーザー向けのレコメンデーションを取得します。パラメータとして、Amazon Personalize のランタイムクライアント、前のステップで作成したキャンペーンの Amazon リソースネーム (ARN)、およびインポートした履歴データからのユーザー ID (例: `123`) を渡します。このメソッドは、推奨アイテムのリストを画面に出力します。

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

## Amazon Personalize のプロジェクトを完了する
<a name="gs-java-example"></a>

SDK for Java 2.x を使用して Amazon Personalize のワークフローを完了する方法を示すオールインワンプロジェクトについては、GitHub の「[Amazon-Personalize-Java-App](https://github.com/seashman/Amazon-Personalize-Java-App)」を参照してください。このプロジェクトには、異なるレシピを使用した複数のソリューションバージョンのトレーニング、および PutEvents 操作を使用したイベントの記録が含まれます。

 その他の例については、AWS SDK サンプルリポジトリの [personalize](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javav2/example_code/personalize/src/main/java/com/example/personalize) フォルダにあるコードを参照してください。