기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.

# 시작하기(Java 2.x용 SDK)
<a name="getting-started-java"></a>

이 자습서에서는 AWS SDK for Java 2.x에서 Personalize 워크플로우를 처음부터 끝까지 완료하는 방법을 보여줍니다.

시작하기 연습을 마쳤을 때 불필요한 요금이 발생하지 않도록 하려면 생성한 리소스를 삭제합니다. 자세한 내용은 [Amazon Personalize 리소스 삭제 요구 사항](deleting-resources.md) 섹션을 참조하세요.

더 많은 예제는 [Personalize 프로젝트 완료](#gs-java-example)단원을 참조하세요.

**Topics**
+ [사전 조건](#gs-java-prerequisites)
+ [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) 절차에 지정된 대로 Java 2.x용 SDK 환경 및 AWS보안 인증을 설정합니다.**

### 자습서
<a name="gs-custom-java-tutorial"></a>

다음에 이어지는 단계에서는 Personalize 패키지를 사용하도록 프로젝트를 설정하고 Personalize Java 2.x용 SDK 클라이언트를 생성합니다. 그런 다음 데이터를 가져와서 캠페인이 포함된 솔루션 버전을 생성 및 배포하고, 추천을 받습니다.

#### 1단계: Personalize 패키지를 사용하도록 프로젝트 설정
<a name="gs-java-set-up-project"></a>

필수 조건을 완료한 후, Personalize 종속 항목을 pom.xml 파일에 추가하고 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단계: Personalize 클라이언트 생성
<a name="getting-started-java-clients"></a>

Personalize 종속 항목을 pom.xml 파일에 추가하고 필요한 패키지를 가져온 후 다음과 같은 Personalize 클라이언트를 생성합니다.

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

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

#### 3단계: 데이터 가져오기
<a name="getting-started-java-import-dataset"></a>

Personalize 클라이언트를 초기화한 후에는 [시작하기 전제 조건](gs-prerequisites.md)완료 시 생성한 과거 데이터를 가져옵니다. 과거 데이터를 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`메서드를 사용하여 Personalize에서 스키마를 생성합니다. Personalize 서비스 클라이언트, 스키마 이름, 이전 단계에서 생성한 스키마 JSON 파일의 파일 경로를 파라미터로 전달합니다. 메서드가 새 스키마의 리소스 이름(ARN)을 반환합니다. 나중에 사용하기 위해 이 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`메서드를 사용하여 데이터세트 그룹을 생성합니다. Personalize 서비스 클라이언트 및 데이터세트 그룹 이름을 파라미터로 전달합니다. 메서드가 새 데이터세트 그룹의 ARN을 반환합니다. 나중에 사용하기 위해 이 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` 메서드를 사용하여 항목 상호 작용 데이터 세트를 생성합니다. Personalize 서비스 클라이언트, 데이터세트 이름, 스키마의 ARN, 데이터세트 그룹의 ARN, 데이터세트 유형에 대한 `Interactions`을 파라미터로 전달합니다. 메서드가 새 데이터세트의 ARN을 반환합니다. 나중에 사용하기 위해 이 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을 반환합니다. 나중에 사용하기 위해 이 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을 반환합니다. 나중에 사용하기 위해 이 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>

솔루션 버전을 학습시키고 평가한 후 Personalize 캠페인을 사용하여 배포할 수 있습니다. 솔루션 버전을 배포하려면 다음 `createPersonalCampaign`메서드를 사용합니다. Personalize 서비스 클라이언트, 이전 단계에서 생성한 솔루션 버전의 리소스 이름(ARN), 캠페인 이름을 파라미터로 전달합니다. 메서드가 새 캠페인의 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);
    }
}
```

Personalize 캠페인에 대한 자세한 내용은 [캠페인을 사용하여 Amazon Personalize 솔루션 버전 배포캠페인 생성](campaigns.md)단원을 참조하세요.

#### 6단계: 추천 받기
<a name="getting-started-java-get-recommendations"></a>

캠페인을 생성한 후 이 캠페인을 사용하여 추천을 받습니다. 사용자에 대한 추천을 받으려면 다음 `getRecs`메서드를 사용합니다. Personalize 런타임 클라이언트, 이전 단계에서 생성한 캠페인의 리소스 이름(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);
        }
    }
```

## Personalize 프로젝트 완료
<a name="gs-java-example"></a>

Java 2.x용 SDK를 사용하여 Personalize 워크플로우를 완료하는 방법을 보여주는 올인원 프로젝트는 GitHub의 [-Personalize-Java-App](https://github.com/seashman/Amazon-Personalize-Java-App)을 참조하세요. 이 프로젝트에는 레시피가 다른 여러 솔루션 버전의 학습과 PutEvents 작업을 통한 이벤트 기록이 포함되어 있습니다.

 추가 예제는 AWSSDK 예제 리포지토리의 [personalize](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javav2/example_code/personalize/src/main/java/com/example/personalize) 폴더에 있는 코드를 참조하세요.