从补丁 198 开始，Amazon Redshift 将不再支持创建新的 Python UDF。现有的 Python UDF 将继续正常运行至 2026 年 6 月 30 日。有关更多信息，请参阅[博客文章](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/)。
# Amazon Redshift ML 的教程
可以使用 Amazon Redshift ML 通过 SQL 语句训练机器学习模型，并在 SQL 查询中调用模型以进行预测。Amazon Redshift 中的机器学习使用一个 SQL 命令训练模型。Amazon Redshift 自动启动 Amazon SageMaker AI 中的训练作业，并生成一个模型。创建模型后，您就可以使用模型的预测函数在 Amazon Redshift 中执行预测。
按照这些教程中的步骤了解 Amazon Redshift ML 功能：
+ [教程：构建客户流失模型](tutorial_customer_churn.md) – 在本教程中，您使用 Amazon Redshift ML 通过 CREATE MODEL 命令创建客户流失模型，并针对用户场景运行预测查询。然后，您可以使用 CREATE MODEL 命令生成的 SQL 函数来实施查询。
+ [教程：构建 K 均值聚类模型](tutorial_k-means_clustering.md) – 在本教程中，您使用 Amazon Redshift ML 基于 [K 均值算法](url-sm-dev;k-means.html)，创建、训练和部署一个机器学习模型。
+ [教程：构建多类别分类模型](tutorial_multi-class_classification.md) – 在本教程中，您使用 Amazon Redshift ML 创建机器学习模型来解决多类别分类问题。多类别分类算法将数据点划分为三个或更多类别中的一个类别。然后，您可以使用 CREATE MODEL 命令生成的 SQL 函数来实施查询。
+ [教程：构建 XGBoost 模型](tutorial_xgboost.md) – 在本教程中，您使用来自 Amazon S3 的数据创建模型，并使用 Amazon Redshift ML 对模型运行预测查询。XGBoost 算法是梯度提升树算法的一种优化实施。
+ [教程：构建回归模型](tutorial_regression.md) – 在本教程中，您使用 Amazon Redshift ML 创建机器学习回归模型，并对该模型运行预测查询。回归模型允许您预测数值结果，例如房屋价格，或有多少人将使用城市的自行车租赁服务。
+ [教程：使用线性学习器构建回归模型](tutorial_linear_learner_regression.md) – 在本教程中，您使用来自 Amazon S3 的数据创建线性学习器模型，并使用 Amazon Redshift ML 对模型运行预测查询。SageMaker AI 线性学习器算法可解决回归或多类别分类问题。
+ [教程：使用线性学习器构建多类别分类模型](tutorial_linear_learner_multi-class_classification.md) – 在本教程中，您使用来自 Amazon S3 的数据创建线性学习器模型，然后使用 Amazon Redshift ML 对模型运行预测查询。SageMaker AI 线性学习器算法可解决回归或分类问题。
# 教程：构建客户流失模型
在本教程中，您使用 Amazon Redshift ML 通过 CREATE MODEL 命令创建客户流失模型，并针对用户场景运行预测查询。然后，您可以使用 CREATE MODEL 命令生成的 SQL 函数来实施查询。
您可以使用简单的 CREATE MODEL 命令导出训练数据、训练模型、导入模型以及准备 Amazon Redshift 预测函数。使用 CREATE MODEL 语句将训练数据指定为表或 SELECT 语句。
该示例使用历史信息构建一个有关移动运营商客户流失的机器学习模型。首先，SageMaker AI 训练您的机器学习模型，然后使用任意客户的资料信息测试您的模型。模型经过验证后，Amazon SageMaker AI 会将模型和预测函数部署到 Amazon Redshift。您可以使用预测函数来预测客户是否会流失。
## 使用案例示例
您可以使用 Amazon Redshift ML 解决其他二进制分类问题，例如预测销售机会是否会关闭。您还可以预测金融交易是否具有欺诈性。
**任务**：
+ 先决条件
+ 步骤 1：将数据从 Amazon S3 加载到 Amazon Redshift
+ 步骤 2：创建机器学习模型
+ 步骤 3：使用模型执行预测
## 先决条件
要完成本教程，您需要满足以下先决条件：
+ 您必须为 Amazon Redshift ML 设置 Amazon Redshift 集群。为此，请使用[适用于 Amazon Redshift ML 管理的集群和配置设置](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html)文档。
+ 您用于创建模型的 Amazon Redshift 集群和用于暂存训练数据和存储模型构件的 Amazon S3 桶必须位于同一个 AWS 区域中。
+ 要下载本文档中使用的 SQL 命令和示例数据集，请执行以下操作之一：
+ 下载 [SQL 命令](https://s3.amazonaws.com/redshift-downloads/redshift-ml/tutorial-scripts/redshift-ml-tutorial.sql)、[客户活动文件](https://s3.amazonaws.com/redshift-downloads/redshift-ml/customer_activity/customer_activity.csv)和[鲍鱼文件](https://s3.amazonaws.com/redshift-downloads/redshift-ml/abalone_xg/abalone.csv)。
+ 将 AWS CLI 用于 Simple Storage Service（Amazon S3），运行以下命令。您可以使用自己的目标路径。
```
aws s3 cp s3://redshift-downloads/redshift-ml/tutorial-scripts/redshift-ml-tutorial.sql
aws s3 cp s3://redshift-downloads/redshift-ml/customer_activity/customer_activity.csv
aws s3 cp s3://redshift-downloads/redshift-ml/abalone_xgb/abalone_xgb.csv
```
## 步骤 1：将数据从 Amazon S3 加载到 Amazon Redshift
使用 [Amazon Redshift 查询器 v2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) 编辑和运行查询并可视化结果。
运行以下查询将创建一个名为 `customer_activity` 的表，并从 Amazon S3 获取示例数据集。
```
DROP TABLE IF EXISTS customer_activity;
CREATE TABLE customer_activity (
state varchar(2),
account_length int,
area_code int,
phone varchar(8),
intl_plan varchar(3),
vMail_plan varchar(3),
vMail_message int,
day_mins float,
day_calls int,
day_charge float,
total_charge float,
eve_mins float,
eve_calls int,
eve_charge float,
night_mins float,
night_calls int,
night_charge float,
intl_mins float,
intl_calls int,
intl_charge float,
cust_serv_calls int,
churn varchar(6),
record_date date
);
COPY customer_activity
FROM 's3://redshift-downloads/redshift-ml/customer_activity/'
REGION 'us-east-1' IAM_ROLE default
FORMAT AS CSV IGNOREHEADER 1;
```
## 步骤 2：创建机器学习模型
在这个模型中，流失是我们的目标输入。模型的所有其他输入是一些属性，它们可帮助创建用于预测流失的函数。
下面的示例使用 CREATE MODEL 操作来提供一个模型，该模型使用诸如客户的年龄、邮政编码、支出和案例等输入来预测客户是否将成为活跃客户。在以下示例中，将 amzn-s3-demo-bucket 替换为您自己的 Amazon S3 存储桶。
```
CREATE MODEL customer_churn_auto_model
FROM
(
SELECT state,
account_length,
area_code,
total_charge/account_length AS average_daily_spend,
cust_serv_calls/account_length AS average_daily_cases,
churn
FROM customer_activity
WHERE record_date < '2020-01-01'
)
TARGET churn FUNCTION ml_fn_customer_churn_auto
IAM_ROLE default SETTINGS (
S3_BUCKET 'amzn-s3-demo-bucket'
);
```
前一个示例中的 SELECT 查询将创建训练数据。TARGET 子句指定哪一列是 CREATE MODEL 操作用于学习如何进行预测的机器学习标签。目标列“流失”表示客户是否仍具有有效会员资格或已暂停会员资格。S3\$1BUCKET 字段是您之前创建的 Amazon S3 桶的名称。Amazon S3 存储桶用于在 Amazon Redshift 和 Amazon SageMaker AI 之间共享训练数据和构件。其余列是用于预测的功能。
有关 CREATE MODEL 命令的基本使用案例的语法和特性的摘要，请参阅[简单 CREATE MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_create_model_use_cases.html#r_simple_create_model)。
### 添加服务器端加密的权限（可选）
默认情况下，Amazon Redshift 使用 Amazon SageMaker AI Autopilot 进行训练。特别是，Amazon Redshift 将训练数据安全地导出到客户指定的 Amazon S3 桶。如果不指定 `KMS_KEY_ID`，则原定设置情况下，会使用服务器端加密 SSE-S3 对数据进行加密。
如果您使用服务器端加密及 AWS KMS 托管式密钥 (SSE-KMS) 对您的输入进行加密，则添加以下权限：
```
{
"Effect": "Allow",
"Action": [
"kms:Encrypt"
"kms:Decrypt"
]
}
```
有关 Amazon SageMaker AI 角色的更多信息，请参阅《Amazon SageMaker AI 开发人员指南》**中的 [Amazon SageMaker AI roles](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html)。
### 检查模型训练的状态（可选）
您可以使用 SHOW MODEL 命令来了解模型何时准备就绪。
使用以下操作检查模型的状态。
```
SHOW MODEL customer_churn_auto_model;
```
以下是上一个操作的输出示例。
```
+--------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Key | Value |
+--------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Model Name | customer_churn_auto_model |
| Schema Name | public |
| Owner | awsuser |
| Creation Time | Tue, 14.06.2022 17:15:52 |
| Model State | TRAINING |
| | |
| TRAINING DATA: | |
| Query | SELECT STATE, ACCOUNT_LENGTH, AREA_CODE, TOTAL_CHARGE / ACCOUNT_LENGTH AS AVERAGE_DAILY_SPEND, CUST_SERV_CALLS / ACCOUNT_LENGTH AS AVERAGE_DAILY_CASES, CHURN |
| | FROM CUSTOMER_ACTIVITY |
| | WHERE RECORD_DATE < '2020-01-01' |
| Target Column | CHURN |
| | |
| PARAMETERS: | |
| Model Type | auto |
| Problem Type | |
| Objective | |
| AutoML Job Name | redshiftml-20220614171552640901 |
| Function Name | ml_fn_customer_churn_auto |
| Function Parameters | state account_length area_code average_daily_spend average_daily_cases |
| Function Parameter Types | varchar int4 int4 float8 int4 |
| IAM Role | default-aws-iam-role |
| S3 Bucket | amzn-s3-demo-bucket |
| Max Runtime | 5400 |
+--------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------+
```
模型训练完成后，`model_state` 变量变为 `Model is Ready`，预测函数变为可用。
## 步骤 3：使用模型执行预测
您可以使用 SQL 语句来查看预测模型所做的预测。在此示例中，由 CREATE MODEL 操作创建的预测函数名为 `ml_fn_customer_churn_auto`。预测函数的输入参数对应于功能的类型，如 varchar 对应于 `state`，而 integer 对应于 `account_length`。预测函数的输出类型与 CREATE MODEL 语句的 TARGET 列相同。
1. 您根据 2020 年 1 月 1 日之前的数据对模型进行了训练，因此，现在您可以对测试集使用预测函数。以下查询显示了 2020 年 1 月 1 日之后注册的客户是否会经历流失的预测。
```
SELECT
phone,
ml_fn_customer_churn_auto(
state,
account_length,
area_code,
total_charge / account_length,
cust_serv_calls / account_length
) AS active
FROM
customer_activity
WHERE
record_date > '2020-01-01';
```
1. 以下示例将相同的预测函数用于不同的使用案例。在此案例中，Amazon Redshift 预测记录日期晚于 2020 年 1 月 1 日的各州客户的流失者和非流失者的比例。
```
WITH predicted AS (
SELECT
state,
ml_fn_customer_churn_auto(
state,
account_length,
area_code,
total_charge / account_length,
cust_serv_calls / account_length
) :: varchar(6) AS active
FROM
customer_activity
WHERE
record_date > '2020-01-01'
)
SELECT
state,
SUM(
CASE
WHEN active = 'True.' THEN 1
ELSE 0
END
) AS churners,
SUM(
CASE
WHEN active = 'False.' THEN 1
ELSE 0
END
) AS nonchurners,
COUNT(*) AS total_per_state
FROM
predicted
GROUP BY
state
ORDER BY
state;
```
1. 以下示例将预测函数用于预测某州客户流失百分比的使用案例。在此案例中，Amazon Redshift 预测记录日期晚于 2020 年 1 月 1 日的流失百分比。
```
WITH predicted AS (
SELECT
state,
ml_fn_customer_churn_auto(
state,
account_length,
area_code,
total_charge / account_length,
cust_serv_calls / account_length
) :: varchar(6) AS active
FROM
customer_activity
WHERE
record_date > '2020-01-01'
)
SELECT
state,
CAST((CAST((SUM(
CASE
WHEN active = 'True.' THEN 1
ELSE 0
END
)) AS FLOAT) / CAST(COUNT(*) AS FLOAT)) AS DECIMAL (3, 2)) AS pct_churn,
COUNT(*) AS total_customers_per_state
FROM
predicted
GROUP BY
state
ORDER BY
3 DESC;
```
## 相关主题
有关 Amazon Redshift ML 的更多信息，请参阅以下文档：
+ [使用 Amazon Redshift ML 的成本](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [CREATE MODEL 命令](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [EXPLAIN\$1MODEL 函数](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)
有关机器学习的更多信息，请参阅以下文档：
+ [机器学习概览](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [面向新手和专家的机器学习](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [机器学习预测的公平性和模型可解释性是什么？](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)
# 教程：构建 K 均值聚类模型
在本教程中，您使用 Amazon Redshift ML 基于 [K 均值算法](url-sm-dev;k-means.html)，创建、训练和部署一个机器学习模型。此算法可解决需要在数据中发现分组的集群问题。K 均值有助于对尚未标注的数据进行分组。要了解有关 K 均值聚类的更多信息，请参阅《Amazon SageMaker AI 开发人员指南》中的 [How K-means Clustering Works](https://docs.aws.amazon.com/sagemaker/latest/dg/algo-kmeans-tech-notes.html)。
您将使用 CREATE MODEL 操作从 Amazon Redshift 集群创建 K 均值模型。您可以使用 CREATE MODEL 命令导出训练数据、训练模型、导入模型以及准备 Amazon Redshift 预测函数。使用 CREATE MODEL 操作将训练数据指定为表或 SELECT 语句。
在本教程中，您将对[全球事件、语言和语调数据库（GDELT）](https://aws.amazon.com/public-datasets/gdelt/)数据集使用 K 均值，该数据集监控世界各地的全球新闻，并且每天每秒都存储数据。K 均值将对语调、参与者或位置相似的事件进行分组。数据以多个文件的形式存储在 Amazon Simple Storage Service 的两个不同文件夹中。这些文件夹是历史文件夹（涵盖 1979 年 - 2013 年）和每日更新（涵盖 2013 年及以后的年份）。在此示例中，我们使用历史格式并引入 1979 年的数据。
## 使用案例示例
您可以使用 Amazon Redshift ML 解决其他聚类问题，例如对在流媒体服务上具有相似观看习惯的客户进行分组。您还可以使用 Redshift ML 来预测配送服务的最佳发货中心数量。
**任务**：
+ 先决条件
+ 步骤 1：将数据从 Amazon S3 加载到 Amazon Redshift
+ 步骤 2：创建机器学习模型
+ 步骤 3：使用模型执行预测
## 先决条件
要完成此教程，必须完成 Amazon Redshift ML 的[管理设置](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html)。
## 步骤 1：将数据从 Amazon S3 加载到 Amazon Redshift
1. 使用 [Amazon Redshift 查询器 v2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) 运行以下查询。查询将剔除公有架构中的 `gdelt_data` 表（如果存在），并在公有架构中创建同名的表。
```
DROP TABLE IF EXISTS gdelt_data CASCADE;
CREATE TABLE gdelt_data (
GlobalEventId bigint,
SqlDate bigint,
MonthYear bigint,
Year bigint,
FractionDate double precision,
Actor1Code varchar(256),
Actor1Name varchar(256),
Actor1CountryCode varchar(256),
Actor1KnownGroupCode varchar(256),
Actor1EthnicCode varchar(256),
Actor1Religion1Code varchar(256),
Actor1Religion2Code varchar(256),
Actor1Type1Code varchar(256),
Actor1Type2Code varchar(256),
Actor1Type3Code varchar(256),
Actor2Code varchar(256),
Actor2Name varchar(256),
Actor2CountryCode varchar(256),
Actor2KnownGroupCode varchar(256),
Actor2EthnicCode varchar(256),
Actor2Religion1Code varchar(256),
Actor2Religion2Code varchar(256),
Actor2Type1Code varchar(256),
Actor2Type2Code varchar(256),
Actor2Type3Code varchar(256),
IsRootEvent bigint,
EventCode bigint,
EventBaseCode bigint,
EventRootCode bigint,
QuadClass bigint,
GoldsteinScale double precision,
NumMentions bigint,
NumSources bigint,
NumArticles bigint,
AvgTone double precision,
Actor1Geo_Type bigint,
Actor1Geo_FullName varchar(256),
Actor1Geo_CountryCode varchar(256),
Actor1Geo_ADM1Code varchar(256),
Actor1Geo_Lat double precision,
Actor1Geo_Long double precision,
Actor1Geo_FeatureID bigint,
Actor2Geo_Type bigint,
Actor2Geo_FullName varchar(256),
Actor2Geo_CountryCode varchar(256),
Actor2Geo_ADM1Code varchar(256),
Actor2Geo_Lat double precision,
Actor2Geo_Long double precision,
Actor2Geo_FeatureID bigint,
ActionGeo_Type bigint,
ActionGeo_FullName varchar(256),
ActionGeo_CountryCode varchar(256),
ActionGeo_ADM1Code varchar(256),
ActionGeo_Lat double precision,
ActionGeo_Long double precision,
ActionGeo_FeatureID bigint,
DATEADDED bigint
);
```
1. 以下查询将示例数据加载到 `gdelt_data` 表。
```
COPY gdelt_data
FROM 's3://gdelt-open-data/events/1979.csv'
REGION 'us-east-1'
IAM_ROLE default
CSV
DELIMITER '\t';
```
### 检查训练数据（可选）
要查看将根据哪些数据训练模型，请使用以下查询。
```
SELECT
AvgTone,
EventCode,
NumArticles,
Actor1Geo_Lat,
Actor1Geo_Long,
Actor2Geo_Lat,
Actor2Geo_Long
FROM
gdelt_data LIMIT 100;
```
## 步骤 2：创建机器学习模型
以下示例使用 CREATE MODEL 命令创建一个模型，该模型将数据分组为七个聚类。K 值是数据点划分到的聚类的数量。该模型将数据点分类为数据点彼此更相似的聚类。通过将数据点聚类为组，K 均值算法以迭代方式确定最佳聚类中心。然后，算法将每个数据点分配给最近的聚类中心。离同一聚类中心最近的成员属于同一组。一个组的成员尽可能与同一组中的其它成员相似，并与其它组的成员尽可能不同。K 值是主观的，取决于测量数据点之间相似性的方法。如果聚类分布不均匀，则可以更改 K 值以平滑聚类大小。
在以下示例中，将 amzn-s3-demo-bucket 替换为您自己的 Amazon S3 存储桶。
```
CREATE MODEL news_data_clusters
FROM
(
SELECT
AvgTone,
EventCode,
NumArticles,
Actor1Geo_Lat,
Actor1Geo_Long,
Actor2Geo_Lat,
Actor2Geo_Long
FROM
gdelt_data
) FUNCTION news_monitoring_cluster
IAM_ROLE default
AUTO OFF
MODEL_TYPE KMEANS
PREPROCESSORS 'none'
HYPERPARAMETERS DEFAULT
EXCEPT
(K '7')
SETTINGS (S3_BUCKET 'amzn-s3-demo-bucket');
```
### 检查模型训练的状态（可选）
您可以使用 SHOW MODEL 命令来了解模型何时准备就绪。
要检查模型状态，请使用以下 SHOW MODEL 操作，并查明 `Model State` 是否为 `Ready`。
```
SHOW MODEL NEWS_DATA_CLUSTERS;
```
当模型准备就绪时，上一个操作的输出应显示 `Model State` 为 `Ready`。以下是 SHOW MODEL 操作的输出示例。
```
+--------------------------+------------------------------------------------------------------------------------------------------+
| Model Name | news_data_clusters |
+--------------------------+------------------------------------------------------------------------------------------------------+
| Schema Name | public |
| Owner | awsuser |
| Creation Time | Fri, 17.06.2022 16:32:19 |
| Model State | READY |
| train:msd | 2973.822754 |
| train:progress | 100.000000 |
| train:throughput | 237114.875000 |
| Estimated Cost | 0.004983 |
| | |
| TRAINING DATA: | |
| Query | SELECT AVGTONE, EVENTCODE, NUMARTICLES, ACTOR1GEO_LAT, ACTOR1GEO_LONG, ACTOR2GEO_LAT, ACTOR2GEO_LONG |
| | FROM GDELT_DATA |
| | |
| PARAMETERS: | |
| Model Type | kmeans |
| Training Job Name | redshiftml-20220617163219978978-kmeans |
| Function Name | news_monitoring_cluster |
| Function Parameters | avgtone eventcode numarticles actor1geo_lat actor1geo_long actor2geo_lat actor2geo_long |
| Function Parameter Types | float8 int8 int8 float8 float8 float8 float8 |
| IAM Role | default-aws-iam-role |
| S3 Bucket | amzn-s3-demo-bucket |
| Max Runtime | 5400 |
| | |
| HYPERPARAMETERS: | |
| feature_dim | 7 |
| k | 7 |
+--------------------------+------------------------------------------------------------------------------------------------------+
```
## 步骤 3：使用模型执行预测
### 标识聚类
您可以找到模型在数据中标识的离散分组，也称为聚类。聚类是指一组数据点，它们离其聚类中心的距离比离任何其他聚类中心都更近。由于 K 值表示模型中的聚类数，因此它也表示聚类中心的数量。以下查询通过显示与每个 `globaleventid` 关联的聚类来标识聚类。
```
SELECT
globaleventid,
news_monitoring_cluster (
AvgTone,
EventCode,
NumArticles,
Actor1Geo_Lat,
Actor1Geo_Long,
Actor2Geo_Lat,
Actor2Geo_Long
) AS cluster
FROM
gdelt_data;
```
### 检查数据的分布
您可以检查数据跨聚类的分布，以查看所选的 K 值是否导致数据在某种程度上均匀分布。使用以下查询来确定数据是否在聚类间均匀分布。
```
SELECT
events_cluster,
COUNT(*) AS nbr_events
FROM
(
SELECT
globaleventid,
news_monitoring_cluster(
AvgTone,
EventCode,
NumArticles,
Actor1Geo_Lat,
Actor1Geo_Long,
Actor2Geo_Lat,
Actor2Geo_Long
) AS events_cluster
FROM
gdelt_data
)
GROUP BY
1;
```
请注意，如果聚类分布不均匀，则可以更改 K 值以平滑聚类大小。
### 确定聚类中心
数据点离其聚类中心的距离比它离任何其他聚类中心都更近。因此，找到聚类中心有助于定义聚类。
运行以下查询，以根据事件代码的文章数量确定聚类的中心。
```
SELECT
news_monitoring_cluster (
AvgTone,
EventCode,
NumArticles,
Actor1Geo_Lat,
Actor1Geo_Long,
Actor2Geo_Lat,
Actor2Geo_Long
) AS events_cluster,
eventcode,
SUM(numArticles) AS numArticles
FROM
gdelt_data
GROUP BY
1,
2;
```
### 显示有关聚类中的数据点的信息
使用以下查询返回分配给第五个聚类的点的数据。选定的文章必须有两个参与者。
```
SELECT
news_monitoring_cluster (
AvgTone,
EventCode,
NumArticles,
Actor1Geo_Lat,
Actor1Geo_Long,
Actor2Geo_Lat,
Actor2Geo_Long
) AS events_cluster,
eventcode,
actor1name,
actor2name,
SUM(numarticles) AS totalarticles
FROM
gdelt_data
WHERE
events_cluster = 5
AND actor1name <> ' '
AND actor2name <> ' '
GROUP BY
1,
2,
3,
4
ORDER BY
5 desc;
```
### 显示具有相同种族代码的参与者的事件数据
下面的查询统计了以积极的语调撰写的有关事件的文章数。该查询还要求两个参与者具有相同的种族代码，并返回每个事件分配到哪个聚类。
```
SELECT
news_monitoring_cluster (
AvgTone,
EventCode,
NumArticles,
Actor1Geo_Lat,
Actor1Geo_Long,
Actor2Geo_Lat,
Actor2Geo_Long
) AS events_cluster,
SUM(numarticles) AS total_articles,
eventcode AS event_code,
Actor1EthnicCode AS ethnic_code
FROM
gdelt_data
WHERE
Actor1EthnicCode = Actor2EthnicCode
AND Actor1EthnicCode <> ' '
AND Actor2EthnicCode <> ' '
AND AvgTone > 0
GROUP BY
1,
3,
4
HAVING
(total_articles) > 4
ORDER BY
1,
2 ASC;
```
## 相关主题
有关 Amazon Redshift ML 的更多信息，请参阅以下文档：
+ [使用 Amazon Redshift ML 的成本](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [CREATE MODEL 操作](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [EXPLAIN\$1MODEL 函数](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)
有关机器学习的更多信息，请参阅以下文档：
+ [机器学习概览](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [面向新手和专家的机器学习](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [机器学习预测的公平性和模型可解释性是什么？](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)
# 教程：构建多类别分类模型
在本教程中，您使用 Amazon Redshift ML 创建机器学习模型来解决多类别分类问题。多类别分类算法将数据点划分为三个或更多类别中的一个类别。然后，您可以使用 CREATE MODEL 命令生成的 SQL 函数来实施查询。
您可以使用 CREATE MODEL 命令导出训练数据、训练模型、导入模型以及准备 Amazon Redshift 预测函数。使用 CREATE MODEL 操作将训练数据指定为表或 SELECT 语句。
要继续学习本教程，您可以使用公用数据集[电子商务销售额预测](https://www.kaggle.com/allunia/e-commerce-sales-forecast)，其中包括一家英国在线零售商的销售数据。您生成的模型将为一个特殊的客户忠诚度计划找出最活跃的客户。通过多类别分类，您可以使用该模型预测客户在 13 个月期间内将有多少个月处于活跃状态。预测函数会指定据预测将活跃 7 个月或更多月数的客户，以便将这些客户加入该计划。
## 使用案例示例
您可以使用 Amazon Redshift ML 解决其他多类别分类问题，例如预测某个产品系列中最畅销的商品。您还可以预测图像中包含哪些水果，例如选择苹果、梨或橘子。
**任务**：
+ 先决条件
+ 步骤 1：将数据从 Amazon S3 加载到 Amazon Redshift
+ 步骤 2：创建机器学习模型
+ 步骤 3：使用模型执行预测
## 先决条件
要完成此教程，必须完成 Amazon Redshift ML 的[管理设置](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html)。
## 步骤 1：将数据从 Amazon S3 加载到 Amazon Redshift
使用 [Amazon Redshift 查询器 v2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) 运行以下查询。这些查询会将示例数据加载到 Amazon Redshift 中。
1. 下面的查询创建一个名为 `ecommerce_sales` 的表。
```
CREATE TABLE IF NOT EXISTS ecommerce_sales (
invoiceno VARCHAR(30),
stockcode VARCHAR(30),
description VARCHAR(60),
quantity DOUBLE PRECISION,
invoicedate VARCHAR(30),
unitprice DOUBLE PRECISION,
customerid BIGINT,
country VARCHAR(25)
);
```
1. 以下查询将[电子商务销售预测数据集](https://www.kaggle.com/allunia/e-commerce-sales-forecast)中的示例数据复制到 `ecommerce_sales` 表中。
```
COPY ecommerce_sales
FROM
's3://redshift-ml-multiclass/ecommerce_data.txt'
IAM_ROLE default
DELIMITER '\t'
IGNOREHEADER 1
REGION 'us-east-1'
MAXERROR 100;
```
### 拆分数据
当您在 Amazon Redshift ML 中创建模型时，SageMaker AI 会自动将您的数据拆分为训练集和测试集，以便 SageMaker AI 可以确定模型的准确性。通过在此步骤中手动拆分数据，您将能够通过分配额外的预测集来验证模型的准确性。
使用以下 SQL 语句将数据拆分为三个用于训练、验证和预测的集。
```
--creates table with all data
CREATE TABLE ecommerce_sales_data AS (
SELECT
t1.stockcode,
t1.description,
t1.invoicedate,
t1.customerid,
t1.country,
t1.sales_amt,
CAST(RANDOM() * 100 AS INT) AS data_group_id
FROM
(
SELECT
stockcode,
description,
invoicedate,
customerid,
country,
SUM(quantity * unitprice) AS sales_amt
FROM
ecommerce_sales
GROUP BY
1,
2,
3,
4,
5
) t1
);
--creates training set
CREATE TABLE ecommerce_sales_training AS (
SELECT
a.customerid,
a.country,
a.stockcode,
a.description,
a.invoicedate,
a.sales_amt,
(b.nbr_months_active) AS nbr_months_active
FROM
ecommerce_sales_data a
INNER JOIN (
SELECT
customerid,
COUNT(
DISTINCT(
DATE_PART(y, CAST(invoicedate AS DATE)) || '-' || LPAD(
DATE_PART(mon, CAST(invoicedate AS DATE)),
2,
'00'
)
)
) AS nbr_months_active
FROM
ecommerce_sales_data
GROUP BY
1
) b ON a.customerid = b.customerid
WHERE
a.data_group_id < 80
);
--creates validation set
CREATE TABLE ecommerce_sales_validation AS (
SELECT
a.customerid,
a.country,
a.stockcode,
a.description,
a.invoicedate,
a.sales_amt,
(b.nbr_months_active) AS nbr_months_active
FROM
ecommerce_sales_data a
INNER JOIN (
SELECT
customerid,
COUNT(
DISTINCT(
DATE_PART(y, CAST(invoicedate AS DATE)) || '-' || LPAD(
DATE_PART(mon, CAST(invoicedate AS DATE)),
2,
'00'
)
)
) AS nbr_months_active
FROM
ecommerce_sales_data
GROUP BY
1
) b ON a.customerid = b.customerid
WHERE
a.data_group_id BETWEEN 80
AND 90
);
--creates prediction set
CREATE TABLE ecommerce_sales_prediction AS (
SELECT
customerid,
country,
stockcode,
description,
invoicedate,
sales_amt
FROM
ecommerce_sales_data
WHERE
data_group_id > 90);
```
## 步骤 2：创建机器学习模型
在此步骤中，您使用 CREATE MODEL 语句通过多类别分类来创建机器学习模型。
以下查询使用 CREATE MODEL 操作通过训练集来创建多类别分类模型。将 amzn-s3-demo-bucket 替换为您自己的 Amazon S3 存储桶。
```
CREATE MODEL ecommerce_customer_activity
FROM
(
SELECT
customerid,
country,
stockcode,
description,
invoicedate,
sales_amt,
nbr_months_active
FROM
ecommerce_sales_training
) TARGET nbr_months_active FUNCTION predict_customer_activity IAM_ROLE default PROBLEM_TYPE MULTICLASS_CLASSIFICATION SETTINGS (
S3_BUCKET 'amzn-s3-demo-bucket',
S3_GARBAGE_COLLECT OFF
);
```
在此查询中，您可以将问题类型指定为 `Multiclass_Classification`。您为模型预测的目标是 `nbr_months_active`。当 SageMaker AI 完成模型训练后，它会创建 `predict_customer_activity` 函数，您将使用该函数在 Amazon Redshift 中进行预测。
### 显示模型训练的状态（可选）
您可以使用 SHOW MODEL 命令来了解模型何时准备就绪。
使用以下查询返回模型的各种指标，包括模型状态和准确性。
```
SHOW MODEL ecommerce_customer_activity;
```
当模型准备就绪时，上一个操作的输出应显示 `Model State` 为 `Ready`。以下是 SHOW MODEL 操作的输出示例。
```
+--------------------------+-----------------------------------------------------------------------------------------------+
| Model Name | ecommerce_customer_activity |
+--------------------------+-----------------------------------------------------------------------------------------------+
| Schema Name | public |
| Owner | awsuser |
| Creation Time | Fri, 17.06.2022 19:02:15 |
| Model State | READY |
| Training Job Status | MaxAutoMLJobRuntimeReached |
| validation:accuracy | 0.991280 |
| Estimated Cost | 7.897689 |
| | |
| TRAINING DATA: | |
| Query | SELECT CUSTOMERID, COUNTRY, STOCKCODE, DESCRIPTION, INVOICEDATE, SALES_AMT, NBR_MONTHS_ACTIVE |
| | FROM ECOMMERCE_SALES_TRAINING |
| Target Column | NBR_MONTHS_ACTIVE |
| | |
| PARAMETERS: | |
| Model Type | xgboost |
| Problem Type | MulticlassClassification |
| Objective | Accuracy |
| AutoML Job Name | redshiftml-20220617190215268770 |
| Function Name | predict_customer_activity |
| Function Parameters | customerid country stockcode description invoicedate sales_amt |
| Function Parameter Types | int8 varchar varchar varchar varchar float8 |
| IAM Role | default-aws-iam-role |
| S3 Bucket | amzn-s3-demo-bucket |
| Max Runtime | 5400 |
+--------------------------+-----------------------------------------------------------------------------------------------+
```
## 步骤 3：使用模型执行预测
以下查询显示哪些客户有资格加入您的客户忠诚度计划。如果模型预测客户将活跃至少七个月，则模型将选择该客户加入忠诚度计划。
```
SELECT
customerid,
predict_customer_activity(
customerid,
country,
stockcode,
description,
invoicedate,
sales_amt
) AS predicted_months_active
FROM
ecommerce_sales_prediction
WHERE
predicted_months_active >= 7
GROUP BY
1,
2
LIMIT
10;
```
### 对验证数据运行预测查询（可选）
针对验证数据运行以下预测查询，以查看模型的准确性级别。
```
SELECT
CAST(SUM(t1.match) AS decimal(7, 2)) AS predicted_matches,
CAST(SUM(t1.nonmatch) AS decimal(7, 2)) AS predicted_non_matches,
CAST(SUM(t1.match + t1.nonmatch) AS decimal(7, 2)) AS total_predictions,
predicted_matches / total_predictions AS pct_accuracy
FROM
(
SELECT
customerid,
country,
stockcode,
description,
invoicedate,
sales_amt,
nbr_months_active,
predict_customer_activity(
customerid,
country,
stockcode,
description,
invoicedate,
sales_amt
) AS predicted_months_active,
CASE
WHEN nbr_months_active = predicted_months_active THEN 1
ELSE 0
END AS match,
CASE
WHEN nbr_months_active <> predicted_months_active THEN 1
ELSE 0
END AS nonmatch
FROM
ecommerce_sales_validation
)t1;
```
### 预测有多少客户错过了加入机会（可选）
以下查询比较据预测仅活跃 5 个月或 6 个月的客户数量。该模型预测这些客户将错失忠诚度计划。然后，此查询将几乎可以不错过该计划的数量与预测有资格加入忠诚度计划的数量进行比较。此查询可用于决定是否降低忠诚度计划的门槛。您还可以确定是否有大量客户据预测几乎可以不错过该计划。然后，您可以鼓励这些客户增加其活动以获得忠诚度计划会员资格。
```
SELECT
predict_customer_activity(
customerid,
country,
stockcode,
description,
invoicedate,
sales_amt
) AS predicted_months_active,
COUNT(customerid)
FROM
ecommerce_sales_prediction
WHERE
predicted_months_active BETWEEN 5 AND 6
GROUP BY
1
ORDER BY
1 ASC
LIMIT
10)
UNION
(SELECT
NULL AS predicted_months_active,
COUNT (customerid)
FROM
ecommerce_sales_prediction
WHERE
predict_customer_activity(
customerid,
country,
stockcode,
description,
invoicedate,
sales_amt
) >=7);
```
## 相关主题
有关 Amazon Redshift ML 的更多信息，请参阅以下文档：
+ [使用 Amazon Redshift ML 的成本](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [CREATE MODEL 操作](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [EXPLAIN\$1MODEL 函数](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)
有关机器学习的更多信息，请参阅以下文档：
+ [机器学习概览](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [面向新手和专家的机器学习](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [机器学习预测的公平性和模型可解释性是什么？](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)
# 教程：构建 XGBoost 模型
在本教程中，您使用来自 Amazon S3 的数据创建模型，并使用 Amazon Redshift ML 对模型运行预测查询。XGBoost 算法是梯度提升树算法的一种优化实施。与其他梯度提升树算法相比，XGBoost 处理的数据类型和关系更多，数据分布更广泛。您可以使用 XGBoost 来处理回归、二进制分类、多类别分类以及排名问题。有关 XGBoost 算法的更多信息，请参阅《Amazon SageMaker AI 开发人员指南》中的 [XGBoost algorithm](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html)。
带有 `AUTO OFF` 选项的 Amazon Redshift ML `CREATE MODEL` 操作当前支持将 XGBoost 作为 `MODEL_TYPE`。根据您的使用案例，您可以在 `CREATE MODEL` 命令中提供相关信息，例如目标和超参数。
在本教程中，您将使用[钞票验证数据集](https://archive.ics.uci.edu/ml/datasets/banknote+authentication)，这是一个二进制分类问题，用于预测给定的钞票是真钞还是假钞。
## 使用案例示例
您可以使用 Amazon Redshift ML 解决其他二进制分类问题，例如预测接受治疗者是健康的还是患有疾病。您还可以预测电子邮件是否为垃圾邮件。
**任务**：
+ 先决条件
+ 步骤 1：将数据从 Amazon S3 加载到 Amazon Redshift
+ 步骤 2：创建机器学习模型
+ 步骤 3：使用模型执行预测
## 先决条件
要完成此教程，必须完成 Amazon Redshift ML 的[管理设置](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html)。
## 步骤 1：将数据从 Amazon S3 加载到 Amazon Redshift
使用 [Amazon Redshift 查询器 v2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) 运行以下查询。
以下查询创建两个表，从 Amazon S3 加载数据，然后将数据拆分为训练集和测试集。您将使用训练集来训练模型并创建预测函数。然后，您将在测试集上测试预测函数。
```
--create training set table
CREATE TABLE banknoteauthentication_train(
variance FLOAT,
skewness FLOAT,
curtosis FLOAT,
entropy FLOAT,
class INT
);
--Load into training table
COPY banknoteauthentication_train
FROM
's3://redshiftbucket-ml-sagemaker/banknote_authentication/train_data/' IAM_ROLE default REGION 'us-west-2' IGNOREHEADER 1 CSV;
--create testing set table
CREATE TABLE banknoteauthentication_test(
variance FLOAT,
skewness FLOAT,
curtosis FLOAT,
entropy FLOAT,
class INT
);
--Load data into testing table
COPY banknoteauthentication_test
FROM
's3://redshiftbucket-ml-sagemaker/banknote_authentication/test_data/'
IAM_ROLE default
REGION 'us-west-2'
IGNOREHEADER 1
CSV;
```
## 步骤 2：创建机器学习模型
以下查询根据您在上一步中创建的训练集，在 Amazon Redshift ML 中创建 XGBoost 模型。将 `amzn-s3-demo-bucket` 替换为您自己的 `S3_BUCKET`，它将存储您的输入数据集和其他 Redshift ML 构件。
```
CREATE MODEL model_banknoteauthentication_xgboost_binary
FROM
banknoteauthentication_train
TARGET class
FUNCTION func_model_banknoteauthentication_xgboost_binary
IAM_ROLE default
AUTO OFF
MODEL_TYPE xgboost
OBJECTIVE 'binary:logistic'
PREPROCESSORS 'none'
HYPERPARAMETERS DEFAULT
EXCEPT(NUM_ROUND '100')
SETTINGS(S3_BUCKET 'amzn-s3-demo-bucket');
```
### 显示模型训练的状态（可选）
您可以使用 SHOW MODEL 命令来了解模型何时准备就绪。
使用以下查询监控模型训练的进度。
```
SHOW MODEL model_banknoteauthentication_xgboost_binary;
```
如果模型为 `READY`，则 SHOW MODEL 操作还提供 `train:error` 指标，如以下输出示例所示。`train:error` 指标用于衡量模型的准确性，精确到小数点后六位。值为 0 表示最准确，值为 1 表示最不准确。
```
+--------------------------+--------------------------------------------------+
| Model Name | model_banknoteauthentication_xgboost_binary |
+--------------------------+--------------------------------------------------+
| Schema Name | public |
| Owner | awsuser |
| Creation Time | Tue, 21.06.2022 19:07:35 |
| Model State | READY |
| train:error | 0.000000 |
| Estimated Cost | 0.006197 |
| | |
| TRAINING DATA: | |
| Query | SELECT * |
| | FROM "BANKNOTEAUTHENTICATION_TRAIN" |
| Target Column | CLASS |
| | |
| PARAMETERS: | |
| Model Type | xgboost |
| Training Job Name | redshiftml-20220621190735686935-xgboost |
| Function Name | func_model_banknoteauthentication_xgboost_binary |
| Function Parameters | variance skewness curtosis entropy |
| Function Parameter Types | float8 float8 float8 float8 |
| IAM Role | default-aws-iam-role |
| S3 Bucket | amzn-s3-demo-bucket |
| Max Runtime | 5400 |
| | |
| HYPERPARAMETERS: | |
| num_round | 100 |
| objective | binary:logistic |
+--------------------------+--------------------------------------------------+
```
## 步骤 3：使用模型执行预测
### 检查模型的准确性
以下预测查询使用在上一步中创建的预测函数来检查模型的准确性。对测试集运行此查询，以确保模型与训练集的对应关系不会过于紧密。这种紧密的对应关系也称为过拟合，而过拟合可能导致模型做出不可靠的预测。
```
WITH predict_data AS (
SELECT
class AS label,
func_model_banknoteauthentication_xgboost_binary (variance, skewness, curtosis, entropy) AS predicted,
CASE
WHEN label IS NULL THEN 0
ELSE label
END AS actual,
CASE
WHEN actual = predicted THEN 1 :: INT
ELSE 0 :: INT
END AS correct
FROM
banknoteauthentication_test
),
aggr_data AS (
SELECT
SUM(correct) AS num_correct,
COUNT(*) AS total
FROM
predict_data
)
SELECT
(num_correct :: FLOAT / total :: FLOAT) AS accuracy
FROM
aggr_data;
```
### 预测真钞和假钞的数量
以下预测查询返回测试集中预测的真钞和假钞的数量。
```
WITH predict_data AS (
SELECT
func_model_banknoteauthentication_xgboost_binary(variance, skewness, curtosis, entropy) AS predicted
FROM
banknoteauthentication_test
)
SELECT
CASE
WHEN predicted = '0' THEN 'Original banknote'
WHEN predicted = '1' THEN 'Counterfeit banknote'
ELSE 'NA'
END AS banknote_authentication,
COUNT(1) AS count
FROM
predict_data
GROUP BY
1;
```
### 找出真钞和假钞的平均观察值
以下预测查询返回测试集中预测为真钞和假钞的钞票的每个特征的平均值。
```
WITH predict_data AS (
SELECT
func_model_banknoteauthentication_xgboost_binary(variance, skewness, curtosis, entropy) AS predicted,
variance,
skewness,
curtosis,
entropy
FROM
banknoteauthentication_test
)
SELECT
CASE
WHEN predicted = '0' THEN 'Original banknote'
WHEN predicted = '1' THEN 'Counterfeit banknote'
ELSE 'NA'
END AS banknote_authentication,
TRUNC(AVG(variance), 2) AS avg_variance,
TRUNC(AVG(skewness), 2) AS avg_skewness,
TRUNC(AVG(curtosis), 2) AS avg_curtosis,
TRUNC(AVG(entropy), 2) AS avg_entropy
FROM
predict_data
GROUP BY
1
ORDER BY
2;
```
## 相关主题
有关 Amazon Redshift ML 的更多信息，请参阅以下文档：
+ [使用 Amazon Redshift ML 的成本](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [CREATE MODEL 操作](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [EXPLAIN\$1MODEL 函数](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)
有关机器学习的更多信息，请参阅以下文档：
+ [机器学习概览](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [面向新手和专家的机器学习](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [机器学习预测的公平性和模型可解释性是什么？](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)
# 教程：构建回归模型
在本教程中，您使用 Amazon Redshift ML 创建机器学习回归模型，并对该模型运行预测查询。回归模型允许您预测数值结果，例如房屋价格，或有多少人将使用城市的自行车租赁服务。您可以在 Amazon Redshift 中使用 CREATE MODEL 命令来处理您的训练数据。然后，Amazon Redshift ML 编译模型，将经过训练的模型导入到 Redshift 中，并准备一个 SQL 预测函数。您可以在 Amazon Redshift 的 SQL 查询中使用预测函数。
在本教程中，您将使用 Amazon Redshift ML 构建回归模型，该模型可预测在一天中任何给定小时内使用多伦多市自行车共享服务的人数。模型的输入包括节假日和天气状况。您将使用回归模型，因为您需要此问题的数值结果。
您可以使用 CREATE MODEL 命令导出训练数据，训练模型，并使模型在 Amazon Redshift 中可用作 SQL 函数。使用 CREATE MODEL 操作将训练数据指定为表或 SELECT 语句。
## 使用案例示例
您可以使用 Amazon Redshift ML 解决其他回归问题，例如预测客户的生命周期价值。还可以使用 Redshift ML 来预测商品的最能赢利的价格和相应的收入。
**任务**：
+ 先决条件
+ 步骤 1：将数据从 Amazon S3 加载到 Amazon Redshift
+ 步骤 2：创建机器学习模型
+ 步骤 3：验证模型
## 先决条件
要完成此教程，必须完成 Amazon Redshift ML 的[管理设置](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html)。
## 步骤 1：将数据从 Amazon S3 加载到 Amazon Redshift
使用 [Amazon Redshift 查询器 v2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) 运行以下查询。
1. 您必须创建三个表才能将三个公有数据集加载到 Amazon Redshift 中。这些数据集是[多伦多自行车骑行数据](https://open.toronto.ca/dataset/bike-share-toronto-ridership-data/)、[历史天气数据](https://climate.weather.gc.ca/historical_data/search_historic_data_e.html)和[历史节假日数据](https://github.com/uWaterloo/Datasets/blob/master/Holidays/holidays.csv)。在 Amazon Redshift 查询编辑器中运行以下查询，以便创建名为 `ridership`、`weather` 和 `holiday` 的表。
```
CREATE TABLE IF NOT EXISTS ridership (
trip_id INT,
trip_duration_seconds INT,
trip_start_time timestamp,
trip_stop_time timestamp,
from_station_name VARCHAR(50),
to_station_name VARCHAR(50),
from_station_id SMALLINT,
to_station_id SMALLINT,
user_type VARCHAR(20)
);
CREATE TABLE IF NOT EXISTS weather (
longitude_x DECIMAL(5, 2),
latitude_y DECIMAL(5, 2),
station_name VARCHAR(20),
climate_id BIGINT,
datetime_utc TIMESTAMP,
weather_year SMALLINT,
weather_month SMALLINT,
weather_day SMALLINT,
time_utc VARCHAR(5),
temp_c DECIMAL(5, 2),
temp_flag VARCHAR(1),
dew_point_temp_c DECIMAL(5, 2),
dew_point_temp_flag VARCHAR(1),
rel_hum SMALLINT,
rel_hum_flag VARCHAR(1),
precip_amount_mm DECIMAL(5, 2),
precip_amount_flag VARCHAR(1),
wind_dir_10s_deg VARCHAR(10),
wind_dir_flag VARCHAR(1),
wind_spd_kmh VARCHAR(10),
wind_spd_flag VARCHAR(1),
visibility_km VARCHAR(10),
visibility_flag VARCHAR(1),
stn_press_kpa DECIMAL(5, 2),
stn_press_flag VARCHAR(1),
hmdx SMALLINT,
hmdx_flag VARCHAR(1),
wind_chill VARCHAR(10),
wind_chill_flag VARCHAR(1),
weather VARCHAR(10)
);
CREATE TABLE IF NOT EXISTS holiday (holiday_date DATE, description VARCHAR(100));
```
1. 以下查询将示例数据加载到您在上一步中创建的各表中。
```
COPY ridership
FROM
's3://redshift-ml-bikesharing-data/bike-sharing-data/ridership/'
IAM_ROLE default
FORMAT CSV
IGNOREHEADER 1
DATEFORMAT 'auto'
TIMEFORMAT 'auto'
REGION 'us-west-2'
gzip;
COPY weather
FROM
's3://redshift-ml-bikesharing-data/bike-sharing-data/weather/'
IAM_ROLE default
FORMAT csv
IGNOREHEADER 1
DATEFORMAT 'auto'
TIMEFORMAT 'auto'
REGION 'us-west-2'
gzip;
COPY holiday
FROM
's3://redshift-ml-bikesharing-data/bike-sharing-data/holiday/'
IAM_ROLE default
FORMAT csv
IGNOREHEADER 1
DATEFORMAT 'auto'
TIMEFORMAT 'auto'
REGION 'us-west-2'
gzip;
```
1. 以下查询对 `ridership` 和 `weather` 数据集执行转换以消除偏差或异常。消除偏差和异常可提高模型准确性。查询通过创建两个名为 `ridership_view` 和 `weather_view` 的新视图来简化表。
```
CREATE
OR REPLACE VIEW ridership_view AS
SELECT
trip_time,
trip_count,
TO_CHAR(trip_time, 'hh24') :: INT trip_hour,
TO_CHAR(trip_time, 'dd') :: INT trip_day,
TO_CHAR(trip_time, 'mm') :: INT trip_month,
TO_CHAR(trip_time, 'yy') :: INT trip_year,
TO_CHAR(trip_time, 'q') :: INT trip_quarter,
TO_CHAR(trip_time, 'w') :: INT trip_month_week,
TO_CHAR(trip_time, 'd') :: INT trip_week_day
FROM
(
SELECT
CASE
WHEN TRUNC(r.trip_start_time) < '2017-07-01' :: DATE THEN CONVERT_TIMEZONE(
'US/Eastern',
DATE_TRUNC('hour', r.trip_start_time)
)
ELSE DATE_TRUNC('hour', r.trip_start_time)
END trip_time,
COUNT(1) trip_count
FROM
ridership r
WHERE
r.trip_duration_seconds BETWEEN 60
AND 60 * 60 * 24
GROUP BY
1
);
CREATE
OR REPLACE VIEW weather_view AS
SELECT
CONVERT_TIMEZONE(
'US/Eastern',
DATE_TRUNC('hour', datetime_utc)
) daytime,
ROUND(AVG(temp_c)) temp_c,
ROUND(AVG(precip_amount_mm)) precip_amount_mm
FROM
weather
GROUP BY
1;
```
1. 以下查询创建了一个表，该表将来自 `ridership_view` 和 `weather_view` 的所有相关输入属性组合到 `trip_data` 表中。
```
CREATE TABLE trip_data AS
SELECT
r.trip_time,
r.trip_count,
r.trip_hour,
r.trip_day,
r.trip_month,
r.trip_year,
r.trip_quarter,
r.trip_month_week,
r.trip_week_day,
w.temp_c,
w.precip_amount_mm,CASE
WHEN h.holiday_date IS NOT NULL THEN 1
WHEN TO_CHAR(r.trip_time, 'D') :: INT IN (1, 7) THEN 1
ELSE 0
END is_holiday,
ROW_NUMBER() OVER (
ORDER BY
RANDOM()
) serial_number
FROM
ridership_view r
JOIN weather_view w ON (r.trip_time = w.daytime)
LEFT OUTER JOIN holiday h ON (TRUNC(r.trip_time) = h.holiday_date);
```
### 查看示例数据（可选）
以下查询显示表中的条目。您可以运行此操作以确保正确创建了此表。
```
SELECT *
FROM trip_data
LIMIT 5;
```
以下是上一个操作的输出示例。
```
+---------------------+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
| trip_time | trip_count | trip_hour | trip_day | trip_month | trip_year | trip_quarter | trip_month_week | trip_week_day | temp_c | precip_amount_mm | is_holiday | serial_number |
+---------------------+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
| 2017-03-21 22:00:00 | 47 | 22 | 21 | 3 | 17 | 1 | 3 | 3 | 1 | 0 | 0 | 1 |
| 2018-05-04 01:00:00 | 19 | 1 | 4 | 5 | 18 | 2 | 1 | 6 | 12 | 0 | 0 | 3 |
| 2018-01-11 10:00:00 | 93 | 10 | 11 | 1 | 18 | 1 | 2 | 5 | 9 | 0 | 0 | 5 |
| 2017-10-28 04:00:00 | 20 | 4 | 28 | 10 | 17 | 4 | 4 | 7 | 11 | 0 | 1 | 7 |
| 2017-12-31 21:00:00 | 11 | 21 | 31 | 12 | 17 | 4 | 5 | 1 | -15 | 0 | 1 | 9 |
+---------------------+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
```
### 显示属性之间的相关性（可选）
确定相关性有助于衡量属性之间的关联强度。关联级别可以帮助您确定影响目标输出的因素。在本教程中，目标输出为 `trip_count`。
以下查询将创建或替换 `sp_correlation` 过程。您可以使用名为 `sp_correlation` 的存储过程，以显示 Amazon Redshift 的表中某个属性与其他属性之间的相关性。
```
CREATE OR REPLACE PROCEDURE sp_correlation(source_schema_name in varchar(255), source_table_name in varchar(255), target_column_name in varchar(255), output_temp_table_name inout varchar(255)) AS $$
DECLARE
v_sql varchar(max);
v_generated_sql varchar(max);
v_source_schema_name varchar(255)=lower(source_schema_name);
v_source_table_name varchar(255)=lower(source_table_name);
v_target_column_name varchar(255)=lower(target_column_name);
BEGIN
EXECUTE 'DROP TABLE IF EXISTS ' || output_temp_table_name;
v_sql = '
SELECT
''CREATE temp table '|| output_temp_table_name||' AS SELECT ''|| outer_calculation||
'' FROM (SELECT COUNT(1) number_of_items, SUM('||v_target_column_name||') sum_target, SUM(POW('||v_target_column_name||',2)) sum_square_target, POW(SUM('||v_target_column_name||'),2) square_sum_target,''||
inner_calculation||
'' FROM (SELECT ''||
column_name||
'' FROM '||v_source_table_name||'))''
FROM
(
SELECT
DISTINCT
LISTAGG(outer_calculation,'','') OVER () outer_calculation
,LISTAGG(inner_calculation,'','') OVER () inner_calculation
,LISTAGG(column_name,'','') OVER () column_name
FROM
(
SELECT
CASE WHEN atttypid=16 THEN ''DECODE(''||column_name||'',true,1,0)'' ELSE column_name END column_name
,atttypid
,''CAST(DECODE(number_of_items * sum_square_''||rn||'' - square_sum_''||rn||'',0,null,(number_of_items*sum_target_''||rn||'' - sum_target * sum_''||rn||
'')/SQRT((number_of_items * sum_square_target - square_sum_target) * (number_of_items * sum_square_''||rn||
'' - square_sum_''||rn||''))) AS numeric(5,2)) ''||column_name outer_calculation
,''sum(''||column_name||'') sum_''||rn||'',''||
''SUM(trip_count*''||column_name||'') sum_target_''||rn||'',''||
''SUM(POW(''||column_name||'',2)) sum_square_''||rn||'',''||
''POW(SUM(''||column_name||''),2) square_sum_''||rn inner_calculation
FROM
(
SELECT
row_number() OVER (order by a.attnum) rn
,a.attname::VARCHAR column_name
,a.atttypid
FROM pg_namespace AS n
INNER JOIN pg_class AS c ON n.oid = c.relnamespace
INNER JOIN pg_attribute AS a ON c.oid = a.attrelid
WHERE a.attnum > 0
AND n.nspname = '''||v_source_schema_name||'''
AND c.relname = '''||v_source_table_name||'''
AND a.atttypid IN (16,20,21,23,700,701,1700)
)
)
)';
EXECUTE v_sql INTO v_generated_sql;
EXECUTE v_generated_sql;
END;
$$ LANGUAGE plpgsql;
```
下面的查询显示数据集中的目标列、`trip_count` 和其他数值属性之间的相关性。
```
call sp_correlation(
'public',
'trip_data',
'trip_count',
'tmp_corr_table'
);
SELECT
*
FROM
tmp_corr_table;
```
下例显示了上一个 `sp_correlation` 操作的输出。
```
+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
| trip_count | trip_hour | trip_day | trip_month | trip_year | trip_quarter | trip_month_week | trip_week_day | temp_c | precip_amount_mm | is_holiday | serial_number |
+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
| 1 | 0.32 | 0.01 | 0.18 | 0.12 | 0.18 | 0 | 0.02 | 0.53 | -0.07 | -0.13 | 0 |
+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
```
## 步骤 2：创建机器学习模型
1. 以下查询通过指定 80% 的数据集用于训练和 20% 的数据集用于验证，将数据拆分为训练集和验证集。训练集是 ML 模型的输入，用于确定模型的最佳可能算法。创建模型后，您可以使用验证集来验证模型的准确性。
```
CREATE TABLE training_data AS
SELECT
trip_count,
trip_hour,
trip_day,
trip_month,
trip_year,
trip_quarter,
trip_month_week,
trip_week_day,
temp_c,
precip_amount_mm,
is_holiday
FROM
trip_data
WHERE
serial_number > (
SELECT
COUNT(1) * 0.2
FROM
trip_data
);
CREATE TABLE validation_data AS
SELECT
trip_count,
trip_hour,
trip_day,
trip_month,
trip_year,
trip_quarter,
trip_month_week,
trip_week_day,
temp_c,
precip_amount_mm,
is_holiday,
trip_time
FROM
trip_data
WHERE
serial_number <= (
SELECT
COUNT(1) * 0.2
FROM
trip_data
);
```
1. 以下查询创建一个回归模型来预测任何输入日期和时间的 `trip_count` 值。在以下示例中，将 amzn-s3-demo-bucket 替换为您自己的 S3 存储桶。
```
CREATE MODEL predict_rental_count
FROM
training_data TARGET trip_count FUNCTION predict_rental_count
IAM_ROLE default
PROBLEM_TYPE regression
OBJECTIVE 'mse'
SETTINGS (
s3_bucket 'amzn-s3-demo-bucket',
s3_garbage_collect off,
max_runtime 5000
);
```
## 步骤 3：验证模型
1. 使用以下查询输出模型的多个方面，并在输出中找出均方误差指标。均方误差是回归问题的典型准确性指标。
```
show model predict_rental_count;
```
1. 根据验证数据运行以下预测查询，以将预测的行程计数与实际行程计数进行比较。
```
SELECT
trip_time,
actual_count,
predicted_count,
(actual_count - predicted_count) difference
FROM
(
SELECT
trip_time,
trip_count AS actual_count,
PREDICT_RENTAL_COUNT (
trip_hour,
trip_day,
trip_month,
trip_year,
trip_quarter,
trip_month_week,
trip_week_day,
temp_c,
precip_amount_mm,
is_holiday
) predicted_count
FROM
validation_data
)
LIMIT
5;
```
1. 以下查询根据您的验证数据计算均方误差和均方根误差。您可以使用均方误差和均方根误差，来测量预测的数值目标与实际数值答案之间的差距。一个好的模型在这两个指标中的分数都很低。下面的查询返回这两个指标的值。
```
SELECT
ROUND(
AVG(POWER((actual_count - predicted_count), 2)),
2
) mse,
ROUND(
SQRT(AVG(POWER((actual_count - predicted_count), 2))),
2
) rmse
FROM
(
SELECT
trip_time,
trip_count AS actual_count,
PREDICT_RENTAL_COUNT (
trip_hour,
trip_day,
trip_month,
trip_year,
trip_quarter,
trip_month_week,
trip_week_day,
temp_c,
precip_amount_mm,
is_holiday
) predicted_count
FROM
validation_data
);
```
1. 以下查询计算 2017 年 1 月 1 日每次行程时间的行程计数误差百分比。该查询对行程时间进行排序，采用的顺序为从误差百分比最低的时间到误差百分比最高的时间。
```
SELECT
trip_time,
CAST(ABS(((actual_count - predicted_count) / actual_count)) * 100 AS DECIMAL (7,2)) AS pct_error
FROM
(
SELECT
trip_time,
trip_count AS actual_count,
PREDICT_RENTAL_COUNT (
trip_hour,
trip_day,
trip_month,
trip_year,
trip_quarter,
trip_month_week,
trip_week_day,
temp_c,
precip_amount_mm,
is_holiday
) predicted_count
FROM
validation_data
)
WHERE
trip_time LIKE '2017-01-01 %%:%%:%%'
ORDER BY
2 ASC;
```
## 相关主题
有关 Amazon Redshift ML 的更多信息，请参阅以下文档：
+ [使用 Amazon Redshift ML 的成本](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [CREATE MODEL 操作](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [EXPLAIN\$1MODEL 函数](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)
有关机器学习的更多信息，请参阅以下文档：
+ [机器学习概览](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [面向新手和专家的机器学习](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [机器学习预测的公平性和模型可解释性是什么？](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)
# 教程：使用线性学习器构建回归模型
在本教程中，您使用来自 Amazon S3 的数据创建线性学习器模型，并使用 Amazon Redshift ML 对模型运行预测查询。SageMaker AI 线性学习器算法可解决回归或多类别分类问题。要了解有关回归和多类别分类问题的更多信息，请参阅《Amazon SageMaker AI 开发人员指南》中的 [Problem types for the machine learning paradigms](https://docs.aws.amazon.com/sagemaker/latest/dg/algorithms-choose.html#basic-machine-learning-paradigms)。在本教程中，您将解决一个回归问题。线性学习器算法并行训练许多模型，并自动确定最优化的模型。您可以在 Amazon Redshift 中使用 CREATE MODEL 操作，该操作使用 SageMaker AI 创建线性学习器模型，并将预测函数发送到 Amazon Redshift。有关线性学习器算法的更多信息，请参阅《Amazon SageMaker AI 开发人员指南》中的 [Linear Learner Algorithm](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html)。
您可以使用 CREATE MODEL 命令导出训练数据、训练模型、导入模型以及准备 Amazon Redshift 预测函数。使用 CREATE MODEL 操作将训练数据指定为表或 SELECT 语句。
线性学习器模型可以优化连续目标或离散目标。连续目标用于回归，而离散变量用于分类。一些方法仅为连续目标提供解决方案，例如回归方法。线性学习器算法提供了比朴素超参数优化技术（如朴素贝叶斯技术）更快的速度。朴素优化技术假定每个输入变量都是独立的。要使用线性学习器算法，必须提供表示输入维度的列和表示观察值的行。有关线性学习器算法的更多信息，请参阅《Amazon SageMaker AI 开发人员指南》中的 [Linear Learner Algorithm](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html)。
在本教程中，您将构建预测鲍鱼年龄的线性学习器模型。您可以对[鲍鱼数据集](http://archive.ics.uci.edu/ml/datasets/Abalone)使用 CREATE MODEL 命令，以确定鲍鱼的物理测量值之间的关系。然后，您可以使用该模型来确定鲍鱼的年龄。
## 使用案例示例
您可以使用线性学习器和 Amazon Redshift ML 解决其他回归问题，例如预测房屋价格。也可以使用 Redshift ML 来预测将使用城市自行车租赁服务的人数。
**任务**：
+ 先决条件
+ 步骤 1：将数据从 Amazon S3 加载到 Amazon Redshift
+ 步骤 2：创建机器学习模型
+ 步骤 3：验证模型
## 先决条件
要完成此教程，必须完成 Amazon Redshift ML 的[管理设置](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html)。
## 步骤 1：将数据从 Amazon S3 加载到 Amazon Redshift
使用 [Amazon Redshift 查询器 v2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) 运行以下查询。这些查询将示例数据加载到 Redshift 中，然后将数据划分为训练集和验证集。
1. 以下查询将创建 `abalone_dataset` 表。
```
CREATE TABLE abalone_dataset (
id INT IDENTITY(1, 1),
Sex CHAR(1),
Length float,
Diameter float,
Height float,
Whole float,
Shucked float,
Viscera float,
Shell float,
Rings integer
);
```
1. 下面的查询将 Amazon S3 的[鲍鱼数据集](http://archive.ics.uci.edu/ml/datasets/Abalone)中的示例数据复制到您之前在 Amazon Redshift 中创建的 `abalone_dataset` 表中。
```
COPY abalone_dataset
FROM
's3://redshift-ml-multiclass/abalone.csv' REGION 'us-east-1' IAM_ROLE default CSV IGNOREHEADER 1 NULL AS 'NULL';
```
1. 通过手动拆分数据，您将能够通过分配额外的预测集来验证模型的准确性。以下查询将数据拆分为两个集。`abalone_training` 表用于训练，`abalone_validation` 表用于验证。
```
CREATE TABLE abalone_training as
SELECT
*
FROM
abalone_dataset
WHERE
mod(id, 10) < 8;
CREATE TABLE abalone_validation as
SELECT
*
FROM
abalone_dataset
WHERE
mod(id, 10) >= 8;
```
## 步骤 2：创建机器学习模型
在此步骤中，您将使用 CREATE MODEL 语句，通过线性学习器算法创建机器学习模型。
以下查询使用您的 S3 桶通过 CREATE MODEL 操作创建线性学习器模型。将 amzn-s3-demo-bucket 替换为您自己的 S3 存储桶。
```
CREATE MODEL model_abalone_ring_prediction
FROM
(
SELECT
Sex,
Length,
Diameter,
Height,
Whole,
Shucked,
Viscera,
Shell,
Rings AS target_label
FROM
abalone_training
) TARGET target_label FUNCTION f_abalone_ring_prediction IAM_ROLE default MODEL_TYPE LINEAR_LEARNER PROBLEM_TYPE REGRESSION OBJECTIVE 'MSE' SETTINGS (
S3_BUCKET 'amzn-s3-demo-bucket',
MAX_RUNTIME 15000
);
```
### 显示模型训练的状态（可选）
您可以使用 SHOW MODEL 命令来了解模型何时准备就绪。
使用以下查询监控模型训练的进度。
```
SHOW MODEL model_abalone_ring_prediction;
```
模型准备就绪后，上一个操作的输出内容应类似于以下示例。请注意，输出提供了 `validation:mse` 指标，这是均方误差。在下一个步骤中，您将使用均方误差验证模型的准确性。
```
+--------------------------+----------------------------------------------------------------------------------------------------+
| Model Name | model_abalone_ring_prediction |
+--------------------------+----------------------------------------------------------------------------------------------------+
| Schema Name | public |
| Owner | awsuser |
| Creation Time | Thu, 30.06.2022 18:00:10 |
| Model State | READY |
| validation:mse | 4.168633 |
| Estimated Cost | 4.291608 |
| | |
| TRAINING DATA: | |
| Query | SELECT SEX , LENGTH , DIAMETER , HEIGHT , WHOLE , SHUCKED , VISCERA , SHELL, RINGS AS TARGET_LABEL |
| | FROM ABALONE_TRAINING |
| Target Column | TARGET_LABEL |
| | |
| PARAMETERS: | |
| Model Type | linear_learner |
| Problem Type | Regression |
| Objective | MSE |
| AutoML Job Name | redshiftml-20220630180010947843 |
| Function Name | f_abalone_ring_prediction |
| Function Parameters | sex length diameter height whole shucked viscera shell |
| Function Parameter Types | bpchar float8 float8 float8 float8 float8 float8 float8 |
| IAM Role | default-aws-iam-role |
| S3 Bucket | amzn-s3-demo-bucket |
| Max Runtime | 15000 |
+--------------------------+----------------------------------------------------------------------------------------------------+
```
## 步骤 3：验证模型
1. 以下预测查询通过计算均方误差和均方根误差来验证模型对于 `abalone_validation` 数据集的准确性。
```
SELECT
ROUND(AVG(POWER((tgt_label - predicted), 2)), 2) mse,
ROUND(SQRT(AVG(POWER((tgt_label - predicted), 2))), 2) rmse
FROM
(
SELECT
Sex,
Length,
Diameter,
Height,
Whole,
Shucked,
Viscera,
Shell,
Rings AS tgt_label,
f_abalone_ring_prediction(
Sex,
Length,
Diameter,
Height,
Whole,
Shucked,
Viscera,
Shell
) AS predicted,
CASE
WHEN tgt_label = predicted then 1
ELSE 0
END AS match,
CASE
WHEN tgt_label <> predicted then 1
ELSE 0
END AS nonmatch
FROM
abalone_validation
) t1;
```
上一个查询的输出应类似于以下示例。均方误差指标的值应类似于由 SHOW MODEL 操作的输出所显示的 `validation:mse` 指标。
```
+-----+--------------------+
| mse | rmse |
+-----+--------------------+
| 5.1 | 2.2600000000000002 |
+-----+--------------------+
```
1. 使用以下查询对预测函数运行 EXPLAIN\$1MODEL 操作。该操作将返回模型可解释性报告。有关 EXPLAIN\$1MODEL 操作的更多信息，请参阅《Amazon Redshift 数据库开发人员指南》中的 [EXPLAIN\$1MODEL 函数](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)。
```
SELECT
EXPLAIN_MODEL ('model_abalone_ring_prediction');
```
以下信息是之前的 EXPLAIN\$1MODEL 操作生成的模型可解释性报告的示例。每个输入的值都是 Shapley 值。Shapley 值表示每个输入对模型预测的影响，值较高的输入对预测的影响更大。在此示例中，值较高的输入对预测鲍鱼年龄的影响更大。
```
{
"explanations": {
"kernel_shap": {
"label0": {
"expected_value" :10.290688514709473,
"global_shap_values": {
"diameter" :0.6856910187882492,
"height" :0.4415323937124035,
"length" :0.21507476107609084,
"sex" :0.448611774505744,
"shell" :1.70426496893776,
"shucked" :2.1181392924386994,
"viscera" :0.342220754059912,
"whole" :0.6711906974084011
}
}
}
},
"version" :"1.0"
};
```
1. 使用以下查询计算模型对尚未成熟的鲍鱼进行正确预测的百分比。未成熟的鲍鱼有 10 个或更少的环，正确的预测精确到实际环数的一个环内。
```
SELECT
TRUNC(
SUM(
CASE
WHEN ROUND(
f_abalone_ring_prediction(
Sex,
Length,
Diameter,
Height,
Whole,
Shucked,
Viscera,
Shell
),
0
) BETWEEN Rings - 1
AND Rings + 1 THEN 1
ELSE 0
END
) / CAST(COUNT(SHELL) AS FLOAT),
4
) AS prediction_pct
FROM
abalone_validation
WHERE
Rings <= 10;
```
## 相关主题
有关 Amazon Redshift ML 的更多信息，请参阅以下文档：
+ [使用 Amazon Redshift ML 的成本](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [CREATE MODEL 操作](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [EXPLAIN\$1MODEL 函数](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)
有关机器学习的更多信息，请参阅以下文档：
+ [机器学习概览](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [面向新手和专家的机器学习](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [机器学习预测的公平性和模型可解释性是什么？](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)
# 教程：使用线性学习器构建多类别分类模型
在本教程中，您使用来自 Amazon S3 的数据创建线性学习器模型，然后使用 Amazon Redshift ML 对模型运行预测查询。SageMaker AI 线性学习器算法可解决回归或分类问题。要了解有关回归和多类别分类问题的更多信息，请参阅《Amazon SageMaker AI 开发人员指南》中的 [Problem types for the machine learning paradigms](https://docs.aws.amazon.com/sagemaker/latest/dg/algorithms-choose.html#basic-machine-learning-paradigms)。在本教程中，您将解决一个多类别分类问题。线性学习器算法并行训练许多模型，并自动确定最优化的模型。您可以在 Amazon Redshift 中使用 CREATE MODEL 操作，该操作使用 SageMaker AI 创建线性学习器模型，并将预测函数发送到 Amazon Redshift。有关线性学习器算法的更多信息，请参阅《Amazon SageMaker AI 开发人员指南》中的 [Linear Learner Algorithm](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html)。
您可以使用 CREATE MODEL 命令导出训练数据、训练模型、导入模型以及准备 Amazon Redshift 预测函数。使用 CREATE MODEL 操作将训练数据指定为表或 SELECT 语句。
线性学习器模型可以优化连续目标或离散目标。连续目标用于回归，而离散变量用于分类。一些方法仅为连续目标提供解决方案，例如回归方法。线性学习器算法提供了比朴素超参数优化技术（如朴素贝叶斯技术）更快的速度。朴素优化技术假定每个输入变量都是独立的。线性学习器算法并行训练许多模型，并选择最优化的模型。一种类似的算法是 XGBoost，它将来自一组更简单和更弱模型的估计值结合起来进行预测。要了解有关 XGBoost 的更多信息，请参阅《Amazon SageMaker AI 开发人员指南》中的 [XGBoost algorithm](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html)。
要使用线性学习器算法，必须提供表示输入维度的列和表示观察值的行。有关线性学习器算法的更多信息，请参阅《Amazon SageMaker AI 开发人员指南》中的 [Linear Learner Algorithm](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html)。
在本教程中，您将构建一个线性学习器模型，用于预测给定区域的覆盖类型。对 UCI 机器学习存储库中的[覆盖类型数据集](https://archive.ics.uci.edu/ml/datasets/covertype)使用 CREATE MODEL 命令。然后，您可以使用由该命令创建的预测函数来确定荒野区域的覆盖类型。森林覆盖类型通常是一种树木。Redshift ML 将用于创建模型的输入包括土壤类型、到道路的距离和荒野区域指定范围。有关数据集的更多信息，请参阅 UCI 机器学习存储库中的[覆盖类型数据集](https://archive.ics.uci.edu/ml/datasets/covertype)。
## 使用案例示例
您可以使用线性学习器及 Amazon Redshift ML 解决其他多类别分类问题，例如从图像中预测植物的种类。您还可以预测客户将要购买的商品的数量。
**任务**：
+ 先决条件
+ 步骤 1：将数据从 Amazon S3 加载到 Amazon Redshift
+ 步骤 2：创建机器学习模型
+ 步骤 3：验证模型
## 先决条件
要完成此教程，必须完成 Amazon Redshift ML 的[管理设置](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html)。
## 步骤 1：将数据从 Amazon S3 加载到 Amazon Redshift
使用 [Amazon Redshift 查询器 v2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) 运行以下查询。这些查询将示例数据加载到 Redshift 中，然后将数据划分为训练集和验证集。
1. 以下查询将创建 `covertype_data` 表。
```
CREATE TABLE public.covertype_data (
elevation bigint ENCODE az64,
aspect bigint ENCODE az64,
slope bigint ENCODE az64,
horizontal_distance_to_hydrology bigint ENCODE az64,
vertical_distance_to_hydrology bigint ENCODE az64,
horizontal_distance_to_roadways bigint ENCODE az64,
hillshade_9am bigint ENCODE az64,
hillshade_noon bigint ENCODE az64,
hillshade_3pm bigint ENCODE az64,
horizontal_distance_to_fire_points bigint ENCODE az64,
wilderness_area1 bigint ENCODE az64,
wilderness_area2 bigint ENCODE az64,
wilderness_area3 bigint ENCODE az64,
wilderness_area4 bigint ENCODE az64,
soil_type1 bigint ENCODE az64,
soil_type2 bigint ENCODE az64,
soil_type3 bigint ENCODE az64,
soil_type4 bigint ENCODE az64,
soil_type5 bigint ENCODE az64,
soil_type6 bigint ENCODE az64,
soil_type7 bigint ENCODE az64,
soil_type8 bigint ENCODE az64,
soil_type9 bigint ENCODE az64,
soil_type10 bigint ENCODE az64,
soil_type11 bigint ENCODE az64,
soil_type12 bigint ENCODE az64,
soil_type13 bigint ENCODE az64,
soil_type14 bigint ENCODE az64,
soil_type15 bigint ENCODE az64,
soil_type16 bigint ENCODE az64,
soil_type17 bigint ENCODE az64,
soil_type18 bigint ENCODE az64,
soil_type19 bigint ENCODE az64,
soil_type20 bigint ENCODE az64,
soil_type21 bigint ENCODE az64,
soil_type22 bigint ENCODE az64,
soil_type23 bigint ENCODE az64,
soil_type24 bigint ENCODE az64,
soil_type25 bigint ENCODE az64,
soil_type26 bigint ENCODE az64,
soil_type27 bigint ENCODE az64,
soil_type28 bigint ENCODE az64,
soil_type29 bigint ENCODE az64,
soil_type30 bigint ENCODE az64,
soil_type31 bigint ENCODE az64,
soil_type32 bigint ENCODE az64,
soil_type33 bigint ENCODE az64,
soil_type34 bigint ENCODE az64,
soil_type35 bigint ENCODE az64,
soil_type36 bigint ENCODE az64,
soil_type37 bigint ENCODE az64,
soil_type38 bigint ENCODE az64,
soil_type39 bigint ENCODE az64,
soil_type40 bigint ENCODE az64,
cover_type bigint ENCODE az64
) DISTSTYLE AUTO;
```
1. 下面的查询将 Amazon S3 的[覆盖类型数据集](https://archive.ics.uci.edu/ml/datasets/covertype)中的示例数据复制到您之前在 Amazon Redshift 中创建的 `covertype_data` 表中。
```
COPY public.covertype_data
FROM
's3://redshift-ml-multiclass/covtype.data.gz' IAM_ROLE DEFAULT gzip DELIMITER ',' REGION 'us-east-1';
```
1. 通过手动拆分数据，您将能够通过分配额外的测试集来验证模型的准确性。以下查询将数据拆分为三个集。`covertype_training` 表用于训练，`covertype_validation` 表用于验证，而 `covertype_test` 表用于测试模型。您将使用训练集来训练模型，并使用验证集来验证模型的开发。然后，您可以使用测试集来测试模型的性能，并查看模型对数据集是过拟合还是欠拟合。
```
CREATE TABLE public.covertype_data_prep AS
SELECT
a.*,
CAST (random() * 100 AS int) AS data_group_id
FROM
public.covertype_data a;
--training dataset
CREATE TABLE public.covertype_training as
SELECT
*
FROM
public.covertype_data_prep
WHERE
data_group_id < 80;
--validation dataset
CREATE TABLE public.covertype_validation AS
SELECT
*
FROM
public.covertype_data_prep
WHERE
data_group_id BETWEEN 80
AND 89;
--test dataset
CREATE TABLE public.covertype_test AS
SELECT
*
FROM
public.covertype_data_prep
WHERE
data_group_id > 89;
```
## 步骤 2：创建机器学习模型
在此步骤中，您将使用 CREATE MODEL 语句，通过线性学习器算法创建机器学习模型。
以下查询使用您的 S3 桶通过 CREATE MODEL 操作创建线性学习器模型。将 amzn-s3-demo-bucket 替换为您自己的 S3 存储桶。
```
CREATE MODEL forest_cover_type_model
FROM
(
SELECT
Elevation,
Aspect,
Slope,
Horizontal_distance_to_hydrology,
Vertical_distance_to_hydrology,
Horizontal_distance_to_roadways,
HIllshade_9am,
Hillshade_noon,
Hillshade_3pm,
Horizontal_Distance_To_Fire_Points,
Wilderness_Area1,
Wilderness_Area2,
Wilderness_Area3,
Wilderness_Area4,
soil_type1,
Soil_Type2,
Soil_Type3,
Soil_Type4,
Soil_Type5,
Soil_Type6,
Soil_Type7,
Soil_Type8,
Soil_Type9,
Soil_Type10,
Soil_Type11,
Soil_Type12,
Soil_Type13,
Soil_Type14,
Soil_Type15,
Soil_Type16,
Soil_Type17,
Soil_Type18,
Soil_Type19,
Soil_Type20,
Soil_Type21,
Soil_Type22,
Soil_Type23,
Soil_Type24,
Soil_Type25,
Soil_Type26,
Soil_Type27,
Soil_Type28,
Soil_Type29,
Soil_Type30,
Soil_Type31,
Soil_Type32,
Soil_Type33,
Soil_Type34,
Soil_Type36,
Soil_Type37,
Soil_Type38,
Soil_Type39,
Soil_Type40,
Cover_type
from
public.covertype_training
) TARGET cover_type FUNCTION predict_cover_type IAM_ROLE default MODEL_TYPE LINEAR_LEARNER PROBLEM_TYPE MULTICLASS_CLASSIFICATION OBJECTIVE 'Accuracy' SETTINGS (
S3_BUCKET 'amzn-s3-demo-bucket',
S3_GARBAGE_COLLECT OFF,
MAX_RUNTIME 15000
);
```
### 显示模型训练的状态（可选）
您可以使用 SHOW MODEL 命令来了解模型何时准备就绪。
使用以下查询监控模型训练的进度。
```
SHOW MODEL forest_cover_type_model;
```
模型准备就绪后，上一个操作的输出内容应类似于以下示例。请注意，输出提供了 `validation:multiclass_accuracy` 指标，您可以在以下示例的右侧查看该指标。多类别准确性用于衡量由模型正确分类的数据点的百分比。在下一步中，您将使用多类别准确性来验证模型的准确性。
```
+--------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Key | Value |
+--------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Model Name | forest_cover_type_model |
| Schema Name | public |
| Owner | awsuser |
| Creation Time | Tue, 12.07.2022 20:24:32 |
| Model State | READY |
| validation:multiclass_accuracy | 0.724952 |
| Estimated Cost | 5.341750 |
| | |
| TRAINING DATA: | |
| Query | SELECT ELEVATION, ASPECT, SLOPE, HORIZONTAL_DISTANCE_TO_HYDROLOGY, VERTICAL_DISTANCE_TO_HYDROLOGY, HORIZONTAL_DISTANCE_TO_ROADWAYS, HILLSHADE_9AM, HILLSHADE_NOON, HILLSHADE_3PM , HORIZONTAL_DISTANCE_TO_FIRE_POINTS, WILDERNESS_AREA1, WILDERNESS_AREA2, WILDERNESS_AREA3, WILDERNESS_AREA4, SOIL_TYPE1, SOIL_TYPE2, SOIL_TYPE3, SOIL_TYPE4, SOIL_TYPE5, SOIL_TYPE6, SOIL_TYPE7, SOIL_TYPE8, SOIL_TYPE9, SOIL_TYPE10 , SOIL_TYPE11, SOIL_TYPE12 , SOIL_TYPE13 , SOIL_TYPE14, SOIL_TYPE15, SOIL_TYPE16, SOIL_TYPE17, SOIL_TYPE18, SOIL_TYPE19, SOIL_TYPE20, SOIL_TYPE21, SOIL_TYPE22, SOIL_TYPE23, SOIL_TYPE24, SOIL_TYPE25, SOIL_TYPE26, SOIL_TYPE27, SOIL_TYPE28, SOIL_TYPE29, SOIL_TYPE30, SOIL_TYPE31, SOIL_TYPE32, SOIL_TYPE33, SOIL_TYPE34, SOIL_TYPE36, SOIL_TYPE37, SOIL_TYPE38, SOIL_TYPE39, SOIL_TYPE40, COVER_TYPE |
| | FROM PUBLIC.COVERTYPE_TRAINING |
| Target Column | COVER_TYPE |
| | |
| PARAMETERS: | |
| Model Type | linear_learner |
| Problem Type | MulticlassClassification |
| Objective | Accuracy |
| AutoML Job Name | redshiftml-20220712202432187659 |
| Function Name | predict_cover_type |
| Function Parameters | elevation aspect slope horizontal_distance_to_hydrology vertical_distance_to_hydrology horizontal_distance_to_roadways hillshade_9am hillshade_noon hillshade_3pm horizontal_distance_to_fire_points wilderness_area1 wilderness_area2 wilderness_area3 wilderness_area4 soil_type1 soil_type2 soil_type3 soil_type4 soil_type5 soil_type6 soil_type7 soil_type8 soil_type9 soil_type10 soil_type11 soil_type12 soil_type13 soil_type14 soil_type15 soil_type16 soil_type17 soil_type18 soil_type19 soil_type20 soil_type21 soil_type22 soil_type23 soil_type24 soil_type25 soil_type26 soil_type27 soil_type28 soil_type29 soil_type30 soil_type31 soil_type32 soil_type33 soil_type34 soil_type36 soil_type37 soil_type38 soil_type39 soil_type40 |
| Function Parameter Types | int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 |
| IAM Role | default-aws-iam-role |
| S3 Bucket | amzn-s3-demo-bucket |
| Max Runtime | 15000 |
+--------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
```
## 步骤 3：验证模型
1. 以下预测查询通过计算多类别准确性来验证模型对于 `covertype_validation` 数据集的准确性。多类别准确性是模型的预测中属于正确预测的百分比。
```
SELECT
CAST(sum(t1.match) AS decimal(7, 2)) AS predicted_matches,
CAST(sum(t1.nonmatch) AS decimal(7, 2)) AS predicted_non_matches,
CAST(sum(t1.match + t1.nonmatch) AS decimal(7, 2)) AS total_predictions,
predicted_matches / total_predictions AS pct_accuracy
FROM
(
SELECT
Elevation,
Aspect,
Slope,
Horizontal_distance_to_hydrology,
Vertical_distance_to_hydrology,
Horizontal_distance_to_roadways,
HIllshade_9am,
Hillshade_noon,
Hillshade_3pm,
Horizontal_Distance_To_Fire_Points,
Wilderness_Area1,
Wilderness_Area2,
Wilderness_Area3,
Wilderness_Area4,
soil_type1,
Soil_Type2,
Soil_Type3,
Soil_Type4,
Soil_Type5,
Soil_Type6,
Soil_Type7,
Soil_Type8,
Soil_Type9,
Soil_Type10,
Soil_Type11,
Soil_Type12,
Soil_Type13,
Soil_Type14,
Soil_Type15,
Soil_Type16,
Soil_Type17,
Soil_Type18,
Soil_Type19,
Soil_Type20,
Soil_Type21,
Soil_Type22,
Soil_Type23,
Soil_Type24,
Soil_Type25,
Soil_Type26,
Soil_Type27,
Soil_Type28,
Soil_Type29,
Soil_Type30,
Soil_Type31,
Soil_Type32,
Soil_Type33,
Soil_Type34,
Soil_Type36,
Soil_Type37,
Soil_Type38,
Soil_Type39,
Soil_Type40,
Cover_type AS actual_cover_type,
predict_cover_type(
Elevation,
Aspect,
Slope,
Horizontal_distance_to_hydrology,
Vertical_distance_to_hydrology,
Horizontal_distance_to_roadways,
HIllshade_9am,
Hillshade_noon,
Hillshade_3pm,
Horizontal_Distance_To_Fire_Points,
Wilderness_Area1,
Wilderness_Area2,
Wilderness_Area3,
Wilderness_Area4,
soil_type1,
Soil_Type2,
Soil_Type3,
Soil_Type4,
Soil_Type5,
Soil_Type6,
Soil_Type7,
Soil_Type8,
Soil_Type9,
Soil_Type10,
Soil_Type11,
Soil_Type12,
Soil_Type13,
Soil_Type14,
Soil_Type15,
Soil_Type16,
Soil_Type17,
Soil_Type18,
Soil_Type19,
Soil_Type20,
Soil_Type21,
Soil_Type22,
Soil_Type23,
Soil_Type24,
Soil_Type25,
Soil_Type26,
Soil_Type27,
Soil_Type28,
Soil_Type29,
Soil_Type30,
Soil_Type31,
Soil_Type32,
Soil_Type33,
Soil_Type34,
Soil_Type36,
Soil_Type37,
Soil_Type38,
Soil_Type39,
Soil_Type40
) AS predicted_cover_type,
CASE
WHEN actual_cover_type = predicted_cover_type THEN 1
ELSE 0
END AS match,
CASE
WHEN actual_cover_type <> predicted_cover_type THEN 1
ELSE 0
END AS nonmatch
FROM
public.covertype_validation
) t1;
```
上一个查询的输出应类似于以下示例。多类别准确性指标的值应类似于由 SHOW MODEL 操作的输出所显示的 `validation:multiclass_accuracy` 指标。
```
+-------------------+-----------------------+-------------------+--------------+
| predicted_matches | predicted_non_matches | total_predictions | pct_accuracy |
+-------------------+-----------------------+-------------------+--------------+
| 41211 | 16324 | 57535 | 0.71627704 |
+-------------------+-----------------------+-------------------+--------------+
```
1. 下面的查询预测了 `wilderness_area2` 的最常见覆盖类型。该数据集包括四个荒野区域和七种覆盖类型。荒野区域可以有多种覆盖类型。
```
SELECT t1. predicted_cover_type, COUNT(*)
FROM
(
SELECT
Elevation,
Aspect,
Slope,
Horizontal_distance_to_hydrology,
Vertical_distance_to_hydrology,
Horizontal_distance_to_roadways,
HIllshade_9am,
Hillshade_noon,
Hillshade_3pm ,
Horizontal_Distance_To_Fire_Points,
Wilderness_Area1,
Wilderness_Area2,
Wilderness_Area3,
Wilderness_Area4,
soil_type1,
Soil_Type2,
Soil_Type3,
Soil_Type4,
Soil_Type5,
Soil_Type6,
Soil_Type7,
Soil_Type8,
Soil_Type9,
Soil_Type10 ,
Soil_Type11,
Soil_Type12 ,
Soil_Type13 ,
Soil_Type14,
Soil_Type15,
Soil_Type16,
Soil_Type17,
Soil_Type18,
Soil_Type19,
Soil_Type20,
Soil_Type21,
Soil_Type22,
Soil_Type23,
Soil_Type24,
Soil_Type25,
Soil_Type26,
Soil_Type27,
Soil_Type28,
Soil_Type29,
Soil_Type30,
Soil_Type31,
Soil_Type32,
Soil_Type33,
Soil_Type34,
Soil_Type36,
Soil_Type37,
Soil_Type38,
Soil_Type39,
Soil_Type40,
predict_cover_type( Elevation,
Aspect,
Slope,
Horizontal_distance_to_hydrology,
Vertical_distance_to_hydrology,
Horizontal_distance_to_roadways,
HIllshade_9am,
Hillshade_noon,
Hillshade_3pm ,
Horizontal_Distance_To_Fire_Points,
Wilderness_Area1,
Wilderness_Area2,
Wilderness_Area3,
Wilderness_Area4,
soil_type1,
Soil_Type2,
Soil_Type3,
Soil_Type4,
Soil_Type5,
Soil_Type6,
Soil_Type7,
Soil_Type8,
Soil_Type9,
Soil_Type10,
Soil_Type11,
Soil_Type12,
Soil_Type13,
Soil_Type14,
Soil_Type15,
Soil_Type16,
Soil_Type17,
Soil_Type18,
Soil_Type19,
Soil_Type20,
Soil_Type21,
Soil_Type22,
Soil_Type23,
Soil_Type24,
Soil_Type25,
Soil_Type26,
Soil_Type27,
Soil_Type28,
Soil_Type29,
Soil_Type30,
Soil_Type31,
Soil_Type32,
Soil_Type33,
Soil_Type34,
Soil_Type36,
Soil_Type37,
Soil_Type38,
Soil_Type39,
Soil_Type40) AS predicted_cover_type
FROM public.covertype_test
WHERE wilderness_area2 = 1)
t1
GROUP BY 1;
```
前一个操作的输出内容应类似如下示例。这一输出意味着，该模型预测大部分覆盖为覆盖类型 1，并且存在一些覆盖类型为 2 和 7 的覆盖。
```
+----------------------+-------+
| predicted_cover_type | count |
+----------------------+-------+
| 2 | 564 |
| 7 | 97 |
| 1 | 2309 |
+----------------------+-------+
```
1. 以下查询显示了单个荒野区域中最常见的覆盖类型。该查询将显示该覆盖类型的数量和覆盖类型的荒野区域。
```
SELECT t1. predicted_cover_type, COUNT(*), wilderness_area
FROM
(
SELECT
Elevation,
Aspect,
Slope,
Horizontal_distance_to_hydrology,
Vertical_distance_to_hydrology,
Horizontal_distance_to_roadways,
HIllshade_9am,
Hillshade_noon,
Hillshade_3pm ,
Horizontal_Distance_To_Fire_Points,
Wilderness_Area1,
Wilderness_Area2,
Wilderness_Area3,
Wilderness_Area4,
soil_type1,
Soil_Type2,
Soil_Type3,
Soil_Type4,
Soil_Type5,
Soil_Type6,
Soil_Type7,
Soil_Type8,
Soil_Type9,
Soil_Type10 ,
Soil_Type11,
Soil_Type12 ,
Soil_Type13 ,
Soil_Type14,
Soil_Type15,
Soil_Type16,
Soil_Type17,
Soil_Type18,
Soil_Type19,
Soil_Type20,
Soil_Type21,
Soil_Type22,
Soil_Type23,
Soil_Type24,
Soil_Type25,
Soil_Type26,
Soil_Type27,
Soil_Type28,
Soil_Type29,
Soil_Type30,
Soil_Type31,
Soil_Type32,
Soil_Type33,
Soil_Type34,
Soil_Type36,
Soil_Type37,
Soil_Type38,
Soil_Type39,
Soil_Type40,
predict_cover_type( Elevation,
Aspect,
Slope,
Horizontal_distance_to_hydrology,
Vertical_distance_to_hydrology,
Horizontal_distance_to_roadways,
HIllshade_9am,
Hillshade_noon,
Hillshade_3pm ,
Horizontal_Distance_To_Fire_Points,
Wilderness_Area1,
Wilderness_Area2,
Wilderness_Area3,
Wilderness_Area4,
soil_type1,
Soil_Type2,
Soil_Type3,
Soil_Type4,
Soil_Type5,
Soil_Type6,
Soil_Type7,
Soil_Type8,
Soil_Type9,
Soil_Type10,
Soil_Type11,
Soil_Type12,
Soil_Type13,
Soil_Type14,
Soil_Type15,
Soil_Type16,
Soil_Type17,
Soil_Type18,
Soil_Type19,
Soil_Type20,
Soil_Type21,
Soil_Type22,
Soil_Type23,
Soil_Type24,
Soil_Type25,
Soil_Type26,
Soil_Type27,
Soil_Type28,
Soil_Type29,
Soil_Type30,
Soil_Type31,
Soil_Type32,
Soil_Type33,
Soil_Type34,
Soil_Type36,
Soil_Type37,
Soil_Type38,
Soil_Type39,
Soil_Type40) AS predicted_cover_type,
CASE WHEN Wilderness_Area1 = 1 THEN 1
WHEN Wilderness_Area2 = 1 THEN 2
WHEN Wilderness_Area3 = 1 THEN 3
WHEN Wilderness_Area4 = 1 THEN 4
ELSE 0
END AS wilderness_area
FROM public.covertype_test)
t1
GROUP BY 1, 3
ORDER BY 2 DESC
LIMIT 1;
```
前一个操作的输出内容应类似如下示例。
```
+----------------------+-------+-----------------+
| predicted_cover_type | count | wilderness_area |
+----------------------+-------+-----------------+
| 2 | 15738 | 1 |
+----------------------+-------+-----------------+
```
## 相关主题
有关 Amazon Redshift ML 的更多信息，请参阅以下文档：
+ [使用 Amazon Redshift ML 的成本](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [CREATE MODEL 操作](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [EXPLAIN\$1MODEL 函数](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)
有关机器学习的更多信息，请参阅以下文档：
+ [机器学习概览](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [面向新手和专家的机器学习](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [机器学习预测的公平性和模型可解释性是什么？](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)