本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# 自定义数据集组入门


**重要**  
在本教程中，创建一个使用自动训练的解决方案。默认情况下，所有新解决方案都使用自动训练。如果使用自动训练，则在解决方案处于活动状态时，就会产生训练费用。为避免产生不必要的费用，请务必在结束后删除解决方案。有关更多信息，请参阅 [删除 Amazon Personalize 资源的要求](deleting-resources.md)。

 本入门指南介绍了如何使用自定义数据集组和 [User-Personalization-v2 配方](native-recipe-user-personalization-v2.md) 配方为用户提供个性化电影推荐。教程使用包含来自 600 个用户对 9700 部电影的 10 万个电影评级的历史数据。

首先，请完成[入门先决条件](gs-prerequisites.md)，然后继续执行[开始使用（控制台）](getting-started-console.md)、[入门 (Amazon CLI)](getting-started-cli.md)、[入门 (SDK for Python (Boto3))](getting-started-python.md)或[入门 (SDK for Java 2.x)](getting-started-java.md)。

完成入门练习后，为避免产生不必要的费用，请删除您创建的资源。有关更多信息，请参阅 [删除 Amazon Personalize 资源的要求](deleting-resources.md)。

**Topics**
+ [

# 开始使用（控制台）
](getting-started-console.md)
+ [

# 入门 (Amazon CLI)
](getting-started-cli.md)
+ [

# 入门 (SDK for Python (Boto3))
](getting-started-python.md)
+ [

# 入门 (SDK for Java 2.x)
](getting-started-java.md)

# 开始使用（控制台）


在本练习中，您将使用 Amazon Personalize 控制台创建一个自定义数据集组，其中含有可为给定用户返回电影推荐的解决方案。在开始本练习之前，请查看[入门先决条件](gs-prerequisites.md)。

完成入门练习后，为避免产生不必要的费用，请删除您创建的资源。有关更多信息，请参阅 [删除 Amazon Personalize 资源的要求](deleting-resources.md)。

## 步骤 1：创建数据集组和数据集


在此过程中，您首先创建一个数据集组。接下来，在数据集组中创建一个 Amazon Personalize *物品交互*数据集。

**创建数据集组和数据集**

1. 在[https://console.aws.amazon.com/personalize/家](https://console.amazonaws.cn/personalize/home)中打开 Amazon Personalize 控制台并登录您的账户。

1. 选择**创建数据集组**。

1. 在**数据集组详细信息**中，对于**数据集组名称**，为您的数据集组指定一个名称。

1. 对于**域**，选择**自定义**。您的屏幕应类似于以下内容：  
![\[描绘了带有“名称”、“域”和“标签”字段的创建数据集组页面。\]](http://docs.amazonaws.cn/personalize/latest/dg/images/gs-1-dataset-group-v02.png)

1. 选择**创建群组**。这时将显示**概览**页面。

1. 在**步骤 1. 创建数据集并导入数据**，选择**创建数据集**，然后选择**物品交互数据集**。

1. 选择**将数据直接导入 Amazon Personalize 数据集**，然后选择**下一步**。

1. 在**配置物品交互数据集**页面上，对于**数据集名称**，为数据集指定名称。

1. 对于**数据集架构**，选择**创建新架构**。在**架构定义**部分，将显示一个最小物品交互架构。该架构与您之前添加到 `ratings.csv` 文件中的标题相匹配，因此您无需进行任何更改。如果您尚未创建训练数据，请参阅[入门先决条件](gs-prerequisites.md)。

1. 对于**架构名称**，为新架构指定一个名称。您的屏幕应类似于以下内容：  
![\[描绘了带有数据集和架构字段的配置物品交互架构页面。\]](http://docs.amazonaws.cn/personalize/latest/dg/images/gs-2-schema.png)

1. 选择**下一步**。将出现**配置物品交互数据集导入作业**页面。接下来，完成[步骤 2：导入物品交互数据](#getting-started-console-import-data)，以导入交互数据。

## 步骤 2：导入物品交互数据


 现在您已经创建了一个数据集，是时候将物品交互数据导入数据集了。

**导入物品交互数据**

1. 在**配置物品交互数据集导入作业**页面上，对于**数据导入源**，选择**从 S3 导入数据**。

1. 对于**数据集导入作业名称**，为导入作业指定名称。

1. 在**需要其他 S3 存储桶策略**对话框中，如果您尚未授予 Amazon Personalize 权限，请按照说明[添加所需的 Amazon S3 存储桶策略](granting-personalize-s3-access.md)。

1. 对于**数据位置**，指定 Amazon Simple Storage Service (S3) 中存储电影数据文件的位置。使用以下语法：

   **s3://amzn-s3-demo-bucket/<folder path>/filename.csv**

1. 在 **IAM 角色**部分，对于 **IAM 服务角色**，选择**输入自定义 IAM 角色 ARN**。

1. 对于**自定义 IAM 角色 ARN**，指定您在[为 Amazon Personalize 创建 IAM 角色](set-up-required-permissions.md#set-up-create-role-with-permissions)中创建的角色。

    **数据集导入作业详细信息**和 **IAM 角色**部分应类似于以下内容：  
![\[描绘了带有导入作业字段的配置物品交互数据集页面。\]](http://docs.amazonaws.cn/personalize/latest/dg/images/gs-3-import-job.png)

1. **将事件指标发布到 S3** 和**标签**部分保持不变，然后选择**开始导入**。数据导入作业开始，并显示**概览**页面。最初，状态为**创建待处理**（然后是**创建正在进行中**），且**创建解决方案**按钮处于禁用状态。

   当数据导入作业已完成时，状态将变为**活动**，并且**创建解决方案**按钮已启用。

1. 现在，您已经导入了数据，可以在[步骤 3：创建解决方案](#getting-started-console-create-solution)中创建解决方案了。

## 步骤 3：创建解决方案


在本教程中，使用在[步骤 2：导入物品交互数据](#getting-started-console-import-data)中导入的数据集来训练模型。经过训练的模型称为*解决方案版本*。

**重要**  
在本教程中，创建一个使用自动训练的解决方案。如果使用自动训练，则在解决方案处于活动状态时，就会产生训练费用。为避免产生不必要的费用，请务必在结束后删除解决方案。有关更多信息，请参阅 [删除 Amazon Personalize 资源的要求](deleting-resources.md)。

**创建解决方案**

1. 在数据集组的**概览**页面上，在**步骤 3. 设置训练和推荐资源**中，选择**创建解决方案**。

1. 对于**解决方案名称**，为您的解决方案指定名称。

1. 对于**解决方案类型**，选择**物品建议**。

1. 在**配方**中，选择 `aws-user-personalization-v2`。

   您的屏幕应类似于以下内容：  
![\[描绘了包含解决方案名称、类型和配方字段的配置解决方案页面。\]](http://docs.amazonaws.cn/personalize/latest/dg/images/gs-5-create-solution.png)

1. 选择**下一步**。**训练配置**字段保持不变。您创建的解决方案每 7 天自动训练新模型，并对最新的物品交互数据给予更多权重。

1. 选择**下一步**，并查看解决方案的详细信息。

1. 选择**创建解决方案**，此时会显示解决方案的详细信息页面。创建解决方案后，Amazon Personalize 将在一小时内开始创建第一个解决方案版本。训练开始后，它会显示在详细信息页面的**解决方案版本**部分，并且您可以监控训练状态。

   当**解决方案版本状态**为*活动* 时，您就可以移动到[步骤 4：创建市场活动](#getting-started-console-deploy-solution)了。

## 步骤 4：创建市场活动


在本过程中，您创建市场活动，以部署您在上一步中创建的解决方案版本。

**创建市场活动**

1. 在导航窗格中，展开**自定义资源**，然后选择**市场活动**。

1. 选择**创建市场活动**。此时，将显示**创建新的市场活动**页面。

1. 在**市场活动详细信息**中，对于**市场活动名称**，为您的市场活动指定一个名称。

1. 对于**解决方案**，选择您在上一步中创建的解决方案。

1. 选择**自动使用最新的解决方案版本**。所有其他字段保持不变。

   您的屏幕应类似于以下内容：  
![\[描绘了带有市场活动配置字段的创建新市场活动页面。\]](http://docs.amazonaws.cn/personalize/latest/dg/images/getting-started-create-new-campaign.png)

1. 选择**创建市场活动**。开始创建市场活动，并显示带有**个性化 API** 部分的市场活动详情页面。

   创建市场活动可能需要几分钟。Amazon Personalize 创建完市场活动后，页面将更新以显示**测试市场活动结果**部分。您的屏幕应类似于以下内容：  
![\[描绘了带有推荐请求字段的测试市场活动部分。\]](http://docs.amazonaws.cn/personalize/latest/dg/images/gs-campaign-test-before-results.png)

## 步骤 5：获得建议


在此过程中，使用您在前一个步骤中创建的活动来获得建议。

**获得建议**

1. 在**测试市场活动结果**中，对于**用户 ID**，指定*评级* 数据集中的值，例如，**83**。所有其他字段保持不变。

1. 选择**获得建议**。“**推荐**” 面板列出了推荐项目的项目 IDs 和分数。

   您的屏幕应类似于以下内容：  
![\[描绘了带有推荐结果的市场活动的测试市场活动部分。\]](http://docs.amazonaws.cn/personalize/latest/dg/images/gs-test-campaign-with-results.png)

# 入门 (Amazon CLI)


在本练习中，您将使用 Amazon Command Line Interface (Amazon CLI) 探索 Amazon Personalize。您创建一个活动，该活动返回给定用户 ID 的电影推荐。

在开始本练习之前，请先执行以下操作：
+ 查看入门[入门先决条件](gs-prerequisites.md)。
+ 设置 Amazon CLI，如[设置 Amazon CLI](aws-personalize-set-up-aws-cli.md)中所述。

完成入门练习后，为避免产生不必要的费用，请删除您创建的资源。有关更多信息，请参阅 [删除 Amazon Personalize 资源的要求](deleting-resources.md)。

**注意**  
本练习中的 Amazon CLI 命令在 Linux 上进行了测试。有关在 Windows 上使用 Amazon CLI 命令的信息，请参阅《Amazon Command Line Interface 用户指南》**中的[为 Amazon Command Line Interface 指定参数值](https://docs.amazonaws.cn/cli/latest/userguide/cli-using-param.html)。

## 步骤 1：导入训练数据


按照步骤操作以创建一个数据集组，向此组添加数据集，然后使用电影评级数据填充此数据集。

1. 通过运行以下命令来创建数据集组。您可以通过传递 [Amazon Key Management Service](https://docs.amazonaws.cn/kms/latest/developerguide/overview.html) 密钥 ARN 和对该密钥具有访问权限的 IAM 角色的 ARN 作为输入参数来加密数据集组。有关 API 的更多信息，请参阅[CreateDatasetGroup](API_CreateDatasetGroup.md)。

   ```
   aws personalize create-dataset-group --name MovieRatingDatasetGroup --kms-key-arn arn:aws:kms:us-west-2:01234567890:key/1682a1e7-a94d-4d92-bbdf-837d3b62315e --role-arn arn:aws:iam::01234567890:KMS-key-access
   ```

   这将显示数据集组 ARN，例如：

   ```
   {
     "datasetGroupArn": "arn:aws:personalize:us-west-2:acct-id:dataset-group/MovieRatingDatasetGroup"
   }
   ```

   使用 `describe-dataset-group` 命令显示您创建的数据集组，并指定返回的数据集组 ARN。

   ```
   aws personalize describe-dataset-group \
   --dataset-group-arn arn:aws:personalize:us-west-2:acct-id:dataset-group/MovieRatingDatasetGroup
   ```

   这将显示此数据集组及其属性，例如：

   ```
   {
       "datasetGroup": {
           "name": "MovieRatingDatasetGroup",
           "datasetGroupArn": "arn:aws:personalize:us-west-2:acct-id:dataset-group/MovieRatingDatasetGroup",
           "status": "ACTIVE",
           "creationDateTime": 1542392161.262,
           "lastUpdatedDateTime": 1542396513.377
       }
   }
   ```
**注意**  
在数据集组中创建数据集之前，等待该组的 `status` 显示为“ACTIVE”。此操作通常很快。

   如果您不记得数据集组 ARN，则使用 `list-dataset-groups` 命令显示您创建的所有数据集组及其 ARN。

   ```
   aws personalize list-dataset-groups
   ```
**注意**  
`describe-object` 和 `list-objects` 命令适用于大多数 Amazon Personalize 对象。这些命令没有在本练习的其余部分中显示，但它们是可用的。

1. 通过将以下代码保存到名为 `MovieRatingSchema.json` 的文件来创建一个 JSON 格式的架构文件。此架构与您之前添加到 `ratings.csv` 的标题匹配。架构名称为 `Interactions`，它与 Amazon Personalize 识别的数据集之一匹配。有关更多信息，请参阅 [为 Amazon Personalize 架构创建架构 JSON 文件](how-it-works-dataset-schema.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. 通过运行以下命令创建架构。指定您在上一个步骤中保存的文件。此示例将该文件显示为属于当前文件夹。有关 API 的更多信息，请参阅[CreateSchema](API_CreateSchema.md)。

   ```
   aws personalize create-schema \
     --name MovieRatingSchema \
     --schema file://MovieRatingSchema.json
   ```

   这将显示架构 Amazon 资源名称 (ARN)，例如：

   ```
   {
     "schemaArn": "arn:aws:personalize:us-west-2:acct-id:schema/MovieRatingSchema"
   }
   ```

1. 通过运行以下命令来创建一个空数据集。提供之前的步骤中返回的数据集组 ARN 和架构 ARN。`dataset-type` 必须与上一个步骤中的架构 `name` 匹配。有关 API 的更多信息，请参阅[CreateDataset](API_CreateDataset.md)。

   ```
   aws personalize create-dataset \
     --name MovieRatingDataset \
     --dataset-group-arn arn:aws:personalize:us-west-2:acct-id:dataset-group/MovieRatingDatasetGroup \
     --dataset-type Interactions \
     --schema-arn arn:aws:personalize:us-west-2:acct-id:schema/MovieRatingSchema
   ```

   这将显示数据集 ARN，例如：

   ```
   {
     "datasetArn": "arn:aws:personalize:us-west-2:acct-id:dataset/MovieRatingDatasetGroup/INTERACTIONS"
   }
   ```

1. 将训练数据添加到数据集。

   1. 通过运行以下命令来创建数据集导入作业。提供之前步骤中返回的数据集 ARN 和 Amazon S3 存储桶名称。提供您在[为 Amazon Personalize 创建 IAM 角色](set-up-required-permissions.md#set-up-create-role-with-permissions)中创建的 Amazon Identity and Access Management (IAM) 角色 ARN。有关 API 的更多信息，请参阅[CreateDatasetImportJob](API_CreateDatasetImportJob.md)。

      ```
      aws personalize create-dataset-import-job \
        --job-name MovieRatingImportJob \
        --dataset-arn arn:aws:personalize:us-west-2:acct-id:dataset/MovieRatingDatasetGroup/INTERACTIONS \
        --data-source dataLocation=s3://amzn-s3-demo-bucket/ratings.csv \
        --role-arn roleArn
      ```

      这将显示数据集导入作业 ARN，例如：

      ```
      {
        "datasetImportJobArn": "arn:aws:personalize:us-west-2:acct-id:dataset-import-job/MovieRatingImportJob"
      }
      ```

   1. 通过使用 `describe-dataset-import-job` 命令来检查状态。提供上一个步骤中返回的数据集导入作业 ARN。有关 API 的更多信息，请参阅[DescribeDatasetImportJob](API_DescribeDatasetImportJob.md)。

      ```
      aws personalize describe-dataset-import-job \
        --dataset-import-job-arn arn:aws:personalize:us-west-2:acct-id:dataset-import-job/MovieRatingImportJob
      ```

      这将显示数据集导入作业的属性，包括其状态。最初，`status` 显示为 CREATE PENDING，例如：

      ```
      {
        "datasetImportJob": {
            "jobName": "MovieRatingImportJob",
            "datasetImportJobArn": "arn:aws:personalize:us-west-2:acct-id:dataset-import-job/MovieRatingImportJob",
            "datasetArn": "arn:aws:personalize:us-west-2:acct-id:dataset/MovieRatingDatasetGroup/INTERACTIONS",
            "dataSource": {
                "dataLocation": "s3://amzn-s3-demo-bucket/ratings.csv"
            },
            "roleArn": "role-arn",
            "status": "CREATE PENDING",
            "creationDateTime": 1542392161.837,
            "lastUpdatedDateTime": 1542393013.377
        }
      }
      ```

      当状态显示为 ACTIVE 时，数据集导入完成。然后，您可以使用指定的数据集来训练模型。
**注意**  
导入需要耗费时间。等待数据集导入完成，然后使用数据集训练模型。

## 步骤 2：创建解决方案（训练模型）


要训练模型，您需要使用 [CreateSolution](API_CreateSolution.md) 操作创建用于训练模型的配置，并开启自动训练。该解决方案会在一小时内自动开始训练第一个解决方案。

使用食谱和训练数据来训练模型。Amazon Personalize 提供一组预定义的食谱。有关更多信息，请参阅 [选择食谱](working-with-predefined-recipes.md)。在本练习中，您使用的是 User-Personalization-v2 配方。

1. 通过运行以下命令创建用于训练模型的配置。此命令创建一个使用自动训练的解决方案。该解决方案每七天（默认值）自动创建一个新的解决方案版本。

   ```
   aws personalize create-solution \
     --name MovieSolution \
     --dataset-group-arn arn:aws:personalize:us-west-2:acct-id:dataset-group/MovieRatingDatasetGroup \
     --recipe-arn arn:aws:personalize:::recipe/aws-user-personalization-v2 \ 
     --perform-auto-training \
     --solution-config "{\"autoTrainingConfig\": {\"schedulingExpression\": \"rate(7 days)\"}}"
   ```

   这将显示解决方案 ARN，例如：

   ```
   {
     "solutionArn": "arn:aws:personalize:us-west-2:acct-id:solution/MovieSolution"
   }
   ```

1. 使用 `describe-solution` 命令检查*创建* 状态。提供上一步中返回的解决方案 ARN。有关 API 的更多信息，请参阅[DescribeSolution](API_DescribeSolution.md)。

   ```
   aws personalize describe-solution \
     --solution-arn arn:aws:personalize:us-west-2:acct-id:solution/MovieSolution
   ```

   这将显示解决方案的属性和创建 `status`。例如：

   ```
   {      
     "solution": {
         "name": "MovieSolution",
         "solutionArn": "arn:aws:personalize:us-west-2:acct-id:solution/MovieSolution",
         "performHPO": false,
         "performAutoML": false,
         "recipeArn": "arn:aws:personalize:::recipe/aws-user-personalization-v2",
         "datasetGroupArn": "arn:aws:personalize:us-west-2:acct-id:dataset-group/MovieRatingDatasetGroup",
         "solutionConfig": {
               "algorithmHyperParameters": {
                   "apply_recency_bias": "true"
               },
               "featureTransformationParameters": {},
               "autoTrainingConfig": {
                   "schedulingExpression": "rate(7 days)"
               }
          },
         "status": "ACTIVE",
         "creationDateTime": "2021-05-12T16:27:59.819000-07:00",
         "lastUpdatedDateTime": "2021-05-12T16:27:59.819000-07:00"
     }
   }
   ```

1.  通过自动训练，解决方案处于活动状态后，解决方案版本训练将在一小时内开始。训练开始后，您可以通过以下 [ListSolutionVersions](https://docs.amazonaws.cn/personalize/latest/dg/API_ListSolutionVersions.html) 命令获取解决方案版本的 Amazon 资源名称（ARN）：

   ```
   aws personalize list-solution-versions --solution-arn arn:aws:personalize:us-west-2:acct-id:solution/MovieSolution
   ```

1. 通过使用 `describe-solution-version` 命令来检查解决方案版本的*训练* 状态。提供上一步中返回的解决方案版本 ARN。有关 API 的更多信息，请参阅[DescribeSolutionVersion](API_DescribeSolutionVersion.md)。

   ```
   aws personalize describe-solution-version \
     --solution-version-arn arn:aws:personalize:us-west-2:acct-id:solution/MovieSolution/version-id
   ```

   将显示解决方案版本的属性和训练 `status`。最初，状态显示为 CREATE PENDING，例如：

   ```
   {
     "solutionVersion": {
         "solutionVersionArn": "arn:aws:personalize:us-west-2:acct-id:solution/MovieSolution/<version-id>",
         ...,
         "status": "CREATE PENDING"
     }
   }
   ```

1. 当解决方案版本 `status` 为活动时，表示训练完成。

   现在，您可以使用解决方案版本，查看训练指标并创建市场活动。
**注意**  
训练需要时间。在活动中使用此版本的解决方案之前，等待训练完成（解决方案的*训练*状态显示为 ACTIVE）。

1. 您可通过检查解决方案版本的指标来验证解决方案的性能。通过运行以下命令来获取解决方案版本的指标。提供之前返回的解决方案版本 ARN。有关 API 的更多信息，请参阅[GetSolutionMetrics](API_GetSolutionMetrics.md)。

   ```
   aws personalize get-solution-metrics \
     --solution-version-arn arn:aws:personalize:us-west-2:acct-id:solution/MovieSolution/version-id
   ```

   此时将显示示例响应：

   ```
   {
     "solutionVersionArn": "arn:aws:personalize:us-west-2:acct-id:solution/www-solution/<version-id>",
     "metrics": {
           "coverage": 0.0485,
           "mean_reciprocal_rank_at_25": 0.0381,
           "normalized_discounted_cumulative_gain_at_10": 0.0363,
           "normalized_discounted_cumulative_gain_at_25": 0.0984,
           "normalized_discounted_cumulative_gain_at_5": 0.0175,
           "precision_at_10": 0.0107,
           "precision_at_25": 0.0207,
           "precision_at_5": 0.0107
       }
   }
   ```

## 步骤 3：创建市场活动（部署解决方案）


您必须先部署解决方案版本，然后才能获得建议。部署解决方案也称为创建活动。一旦您创建活动，您的客户端应用程序就可以使用 [GetRecommendations](API_RS_GetRecommendations.md) API 获得建议。

1. 通过运行以下命令来创建活动。提供上一步中返回的解决方案版本 ARN。有关 API 的更多信息，请参阅[CreateCampaign](API_CreateCampaign.md)。

   ```
   aws personalize create-campaign \
     --name MovieRecommendationCampaign \
     --solution-version-arn arn:aws:personalize:us-west-2:acct-id:solution/MovieSolution/version-id \
     --min-provisioned-tps 1
   ```

   此时将显示示例响应：

   ```
   {
     "campaignArn": "arn:aws:personalize:us-west-2:acct-id:campaign/MovieRecommendationCampaign"
   }
   ```

1. 通过运行以下命令来检查部署状态。提供上一步中返回的活动 ARN。有关 API 的更多信息，请参阅[DescribeCampaign](API_DescribeCampaign.md)。

   ```
   aws personalize describe-campaign \
     --campaign-arn arn:aws:personalize:us-west-2:acct-id:campaign/MovieRecommendationCampaign
   ```

   此时将显示示例响应：

   ```
   {
     "campaign": { 
         "name": "MovieRecommendationCampaign",
         "campaignArn": "arn:aws:personalize:us-west-2:acct-id:campaign/MovieRecommendationCampaign",
         "solutionVersionArn": "arn:aws:personalize:us-west-2:acct-id:solution/MovieSolution/<version-id>",
         "minProvisionedTPS": "1",
         "creationDateTime": 1543864775.923,
         "lastUpdatedDateTime": 1543864791.923,
         "status": "CREATE IN_PROGRESS"
     }
   }
   ```
**注意**  
在获得来自活动的推荐之前，等待 `status` 显示为“ACTIVE”。

## 步骤 4：获得建议


通过运行 `get-recommendations` 命令来获得建议。提供上一步中返回的活动 ARN。在请求中，指定电影评级数据集中的用户 ID。有关 API 的更多信息，请参阅[GetRecommendations](API_RS_GetRecommendations.md)。

**注意**  
并非所有配方都支持 `GetRecommendations` API。有关更多信息，请参阅 [选择食谱](working-with-predefined-recipes.md)。  
您在此步骤中调用的 Amazon CLI 命令 `personalize-runtime` 与您在之前的步骤中所调用的不同。

```
aws personalize-runtime get-recommendations \
  --campaign-arn arn:aws:personalize:us-west-2:acct-id:campaign/MovieRecommendationCampaign \
  --user-id 123
```

在响应中，活动将返回用户可能喜欢的物品推荐（电影 ID）的列表。此列表按用户的相关性进行降序排序。

```
{
  "itemList": [
      {
          "itemId": "14"
      },
      {
          "itemId": "15"
      },
      {
          "itemId": "275"
      },
      {
          "itemId": "283"
      },
      {
          "itemId": "273"
      },
      ...
  ]
}
```

# 入门 (SDK for Python (Boto3))


本教程向您展示如何使用 SDK for Python (Boto3) 从头到尾完成 Amazon Personalize 工作流程。

完成入门练习后，为避免产生不必要的费用，请删除您创建的资源。有关更多信息，请参阅 [删除 Amazon Personalize 资源的要求](deleting-resources.md)。

**Topics**
+ [

## 先决条件
](#gs-sdk-prerequisites)
+ [

## 教程
](#gs-python-custom-tutorial)
+ [

## 开始使用 Jupyter（iPython） APIs 笔记本电脑的 Amazon Personalize
](#gs-jupyter-notebook)

## 先决条件


以下是使用本指南中的 Python 示例的先决条件步骤：
+ 完成[入门先决条件](gs-prerequisites.md)，设置所需权限并创建训练数据。如果您使用自己的源数据，请确保按照先决条件设置数据格式。
+ 按照中的说明设置您的 适用于 Python (Boto3) 的 Amazon SDK 环境[设置 Amazon SDKs](aws-personalize-set-up-sdks.md)。

## 教程


在以下步骤中，您将验证您的环境并为 Amazon Personalize 创建 SDK for Python (Boto3) 客户端。然后，将导入数据，创建解决方案版本并通过市场活动进行部署，随后获得建议。

### 步骤 1：验证您的 Python 环境并创建 boto3 客户端


在完成先决条件之后，请运行以下 Python 示例，以确认您的环境已正确配置。此代码还会创建您在本教程中使用的 Amazon Personalize boto3 客户端。如果已正确配置环境，则会显示可用食谱列表，您现在可以运行本教程中的其他示例。

```
import boto3

personalizeRt = boto3.client('personalize-runtime')
personalize = boto3.client('personalize')

response = personalize.list_recipes()

for recipe in response['recipes']:
    print (recipe)
```

### 步骤 2：导入数据


创建 Amazon Personalize boto3 客户端并验证您的环境后，导入您在完成[入门先决条件](gs-prerequisites.md)时创建的历史数据。要将历史数据导入 Amazon Personalize，请执行以下操作：

1. 使用以下代码创建 Amazon Personalize 架构。将 `getting-started-schema` 替换为架构的名称。

   ```
   import json
   schema = {
     "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"
   }
   
   create_interactions_schema_response = personalize.create_schema(
       name='getting-started-schema',
       schema=json.dumps(schema)
   )
   
   interactions_schema_arn = create_interactions_schema_response['schemaArn']
   print(json.dumps(create_interactions_schema_response, indent=2))
   ```

1. 使用以下代码创建数据集组。将 `dataset group name` 替换为数据集组的名称。

   ```
   response = personalize.create_dataset_group(name = 'dataset group name')
   dataset_group_arn = response['datasetGroupArn']
   
   description = personalize.describe_dataset_group(datasetGroupArn = dataset_group_arn)['datasetGroup']
   
   print('Name: ' + description['name'])
   print('ARN: ' + description['datasetGroupArn'])
   print('Status: ' + description['status'])
   ```

1. 使用以下代码在新数据集组中创建物品交互数据集。为数据集命名，并提供前面步骤中的`schema_arn`和`dataset_group_arn`。

   ```
   response = personalize.create_dataset(
       name = 'datase_name',
       schemaArn = 'schema_arn',
       datasetGroupArn = 'dataset_group_arn',
       datasetType = 'Interactions'
   )
   
   dataset_arn = response['datasetArn']
   ```

1. 使用以下代码通过数据集导入作业导入数据。代码使用 describe\$1dataset\$1import\$1job 方法来跟踪作业的状态。

   将以下内容作为参数传递：作业名称、上一步中的 `dataset_arn`、存储训练数据的 Amazon S3 存储桶路径 (`s3://bucket name/folder name/ratings.csv`) 以及您的 IAM 服务角色的 ARN。您在[入门先决条件](gs-prerequisites.md)期间创建了此角色。Amazon Personalize 需要权限才能访问存储桶。请参阅[向 Amazon Personalize 授予访问 Amazon S3 资源的权限](granting-personalize-s3-access.md)。

   ```
   import time
   response = personalize.create_dataset_import_job(
       jobName = 'JobName',
       datasetArn = 'dataset_arn',
       dataSource = {'dataLocation':'s3://amzn-s3-demo-bucket/filename.csv'},
       roleArn = 'role_arn',
       importMode = 'FULL'
   )
   
   dataset_interactions_import_job_arn = response['datasetImportJobArn']
   
   description = personalize.describe_dataset_import_job(
       datasetImportJobArn = dataset_interactions_import_job_arn)['datasetImportJob']
   
   print('Name: ' + description['jobName'])
   print('ARN: ' + description['datasetImportJobArn'])
   print('Status: ' + description['status'])
   
   max_time = time.time() + 3*60*60 # 3 hours
   while time.time() < max_time:
       describe_dataset_import_job_response = personalize.describe_dataset_import_job(
           datasetImportJobArn = dataset_interactions_import_job_arn
       )
       status = describe_dataset_import_job_response["datasetImportJob"]['status']
       print("Interactions DatasetImportJob: {}".format(status))
       
       if status == "ACTIVE" or status == "CREATE FAILED":
           break
           
       time.sleep(60)
   ```

### 步骤 3：创建解决方案


导入数据后，创建解决方案和解决方案版本，如下所示。*解决方案* 包含用于训练模型的配置，*解决方案版本* 是经过训练的模型。

1.  使用以下代码创建新解决方案。将以下内容作为参数传递：`dataset_group_arn`来自之前的、解决方案的名称和 User-Personalization-v 2 配方的 ARN () `arn:aws:personalize:::recipe/aws-user-personalization-v2`。存储新解决方案的 ARN 以备日后使用。

   ```
   create_solution_response = personalize.create_solution(
     name='solution name', 
     recipeArn= 'arn:aws:personalize:::recipe/aws-user-personalization-v2', 
     datasetGroupArn = 'dataset group arn'
   )
   solution_arn = create_solution_response['solutionArn']
   print('solution_arn: ', solution_arn)
   ```

1. 使用以下代码创建解决方案版本。将上一步中的 `solution_arn` 作为参数传递。以下代码将创建解决方案版本。在训练期间，代码使用 [DescribeSolutionVersion](API_DescribeSolutionVersion.md) 操作来检索解决方案版本的状态。训练完成后，方法将返回新解决方案版本的 ARN。请将其存储以便将来使用。

   ```
   import time
   import json
   
   create_solution_version_response = personalize.create_solution_version(
       solutionArn = solution_arn
   )
   
   solution_version_arn = create_solution_version_response['solutionVersionArn']
   print(json.dumps(create_solution_version_response, indent=2))
   
   max_time = time.time() + 3*60*60 # 3 hours
   while time.time() < max_time:
       describe_solution_version_response = personalize.describe_solution_version(
           solutionVersionArn = solution_version_arn
       )
       status = describe_solution_version_response["solutionVersion"]["status"]
       print("SolutionVersion: {}".format(status))
       
       if status == "ACTIVE" or status == "CREATE FAILED":
           break
           
       time.sleep(60)
   ```

### 步骤 4：创建市场活动


创建解决方案版本后，使用 Amazon Personalize 市场活动进行部署。使用以下代码创建可部署解决方案版本的市场活动。将以下内容作为参数传递：`solution_version_arn` 和市场活动名称。方法将返回新市场活动的 Amazon 资源名称 (ARN)。请将其存储以便将来使用。

```
response = personalize.create_campaign(
    name = 'campaign name',
    solutionVersionArn = 'solution version arn'
)

arn = response['campaignArn']

description = personalize.describe_campaign(campaignArn = arn)['campaign']
print('Name: ' + description['name'])
print('ARN: ' + description['campaignArn'])
print('Status: ' + description['status'])
```

### 步骤 5：获得建议


创建活动之后，您可以使用它来获得建议。以下代码展示了如何从市场活动中获取建议并打印出每个推荐物品的 ID。传递您在上一步中创建的市场活动的 ARN。对于用户 ID，传递来自训练数据的用户 ID，例如 `123`。

```
response = personalizeRt.get_recommendations(
    campaignArn = 'Campaign ARN',
    userId = '123',
    numResults = 10
)

print("Recommended items")
for item in response['itemList']:
    print (item['itemId'])
```

## 开始使用 Jupyter（iPython） APIs 笔记本电脑的 Amazon Personalize


 要开始通过 Jupyter 笔记本使用 Amazon Personalize，请克隆或下载在 [Amazon Personalize 示例](https://github.com/aws-samples/amazon-personalize-samples)存储库的 [getting\$1started](https://github.com/aws-samples/amazon-personalize-samples/tree/master/getting_started) 文件夹中找到的一系列笔记本。笔记本将引导您使用 Amazon Personalize 导入训练数据、创建解决方案、创建市场活动以及获取建议。

**注意**  
 在开始使用笔记本之前，请务必按照 [README.md](https://github.com/aws-samples/amazon-personalize-samples/blob/master/getting_started/README.md) 中的步骤构建您的环境 

# 入门 (SDK for Java 2.x)


本教程向您展示如何使用 Amazon 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)

## 先决条件


以下是完成本教程的先决条件步骤：
+ 完成[入门先决条件](gs-prerequisites.md)，设置所需权限并创建训练数据。您可以使用[开始使用（控制台）](getting-started-console.md)或[入门 (Amazon CLI)](getting-started-cli.md) 练习中所用的相同源数据。如果您使用自己的源数据，请确保按照先决条件中的步骤设置数据格式。
+ 设置 SDK for Java 2.x 环境和 Amazon 凭证，如《Amazon SDK for Java 2.x 开发人员指南》**中的[设置 Amazon SDK for Java 2.x](https://docs.amazonaws.cn/sdk-for-java/latest/developer-guide/setup.html) 过程所述。

### 教程


在以下步骤中，您将项目设置为使用 Amazon Personalize 程序包并创建 Amazon Personalize SDK for Java 2.x 客户端。然后，将导入数据，创建解决方案版本并通过市场活动进行部署，随后获得建议。

#### 步骤 1：设置您的项目以使用 Amazon Personalize 程序包


完成先决条件后，将 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 客户端


将 Amazon Personalize 依赖项添加到 pom.xml 文件并导入所需的程序包之后，创建以下 Amazon Personalize 客户端：

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

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

#### 步骤 3：导入数据


初始化 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：创建解决方案


导入数据后，创建解决方案和解决方案版本，如下所示。*解决方案* 包含用于训练模型的配置，*解决方案版本* 是经过训练的模型。

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：创建市场活动


训练并评估解决方案版本后，使用 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：获得建议


创建市场活动之后，您可以使用它来获得建议。使用以下 `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 项目


有关向您展示如何使用 SDK for Java 2.x 完成 Amazon Personalize 工作流程的多合一项目，请参阅 GitHub 上的 [Amazon-Personalize-Java-App](https://github.com/seashman/Amazon-Personalize-Java-App)。该项目包括使用不同的食谱训练多个解决方案版本，以及使用 PutEvents 操作记录事件。

 有关其他示例，请参阅在 Amazon SDK 示例存储库的[个性化](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javav2/example_code/personalize/src/main/java/com/example/personalize)文件夹中找到的代码。