Amazon Redshift 將不再支援從修補程式 198 開始建立新的 Python UDFs。現有 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 適用於 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-MMS) 的伺服器端加密來加密輸入時，請新增下列許可：
```
{
"Effect": "Allow",
"Action": [
"kms:Encrypt"
"kms:Decrypt"
]
}
```
如需 Amazon SageMaker AI 角色的詳細資訊，請參閱《Amazon SageMaker AI 開發人員指南》**中的 [Amazon SageMaker AI 角色](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`，而整數會用於 `account_length`。預測函數的輸出類型與 CREATE MODEL 陳述式的 TARGET 資料欄相同。
1. 您用了 2020-01-01 之前的資料訓練模型，因此現在您可以在測試集上使用預測功能。以下查詢顯示 2020-01-01 之後註冊的客戶是否會經歷流失的預測。
```
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-01-01)，預測流失者和非流失者的比例。
```
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-01-01 的流失百分比。
```
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 RedshiftML 的成本](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 開發人員指南》中的 [K 平均值叢集的運作方式](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 陳述式。
在本教學課程中，您會在[全球事件、語言和音調資料庫 (Global Database of Events, Language, and Tone (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：執行模型的預測
以下查詢會顯示哪些客戶符合您客戶忠誠度計劃的資格。如果模型預測客戶至少有 7 個月的活躍時間，則模型會為忠誠度計劃選取該客戶。
```
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 演算法](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html)。
Amazon Redshift ML `CREATE MODEL` 操作與 `AUTO OFF` 選項目前支援 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-01-01 的每個行程時間計算行程計數中的百分比誤差。查詢會將行程時間從百分比誤差最低的時間排序到百分比誤差最高的時間。
```
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 開發人員指南》中的[機器學習範例的問題類型](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 開發人員指南》中的[線性學習程式演算法](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html)。
您可以使用 CREATE MODEL 命令來匯出訓練資料、訓練模型、匯入模型，以及準備 Amazon Redshift 預測函數。使用 CREATE MODEL 操作，將訓練資料指定為資料表或 SELECT 陳述式。
線性學習程式模型可最佳化連續目標或離散目標。連續目標用於迴歸，而離散變數用於分類。某些方法會僅針對連續目標提供解決方案，例如迴歸方法。與單純的超參數最佳化技術 (例如 Naive Bayes 技術) 相比，線性學習程式演算法的速度更快。單純的最佳化技術會假定每個輸入變數都是獨立的。若要使用線性學習程式演算法，您必須提供代表輸入維度的資料欄，以及表示觀測值的資料列。如需線性學習程式演算法的相關資訊，請參閱《Amazon SageMaker AI 開發人員指南》中的[線性學習程式演算法](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. 使用下列查詢，在預測函數上執行 EXPLAIIN\$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 開發人員指南》中的[機器學習範例的問題類型](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 開發人員指南》中的[線性學習程式演算法](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html)。
您可以使用 CREATE MODEL 命令來匯出訓練資料、訓練模型、匯入模型，以及準備 Amazon Redshift 預測函數。使用 CREATE MODEL 操作，將訓練資料指定為資料表或 SELECT 陳述式。
線性學習程式模型可最佳化連續目標或離散目標。連續目標用於迴歸，而離散變數用於分類。某些方法會僅針對連續目標提供解決方案，例如迴歸方法。與單純的超參數最佳化技術 (例如 Naive Bayes 技術) 相比，線性學習程式演算法的速度更快。單純的最佳化技術會假定每個輸入變數都是獨立的。線性學習程式演算法可同時訓練許多模型，並選取最佳化程度最高的模型。一個類似的算法是 XGBoost，它結合了一組更簡單和模型更弱的估計來做出預測。如需 XGBoost 的詳細資訊，請參閱《Amazon SageMaker AI 開發人員指南》中的 [XGBoost 演算法](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html)。
若要使用線性學習程式演算法，您必須提供代表輸入維度的資料欄，以及表示觀測值的資料列。如需線性學習程式演算法的相關資訊，請參閱《Amazon SageMaker AI 開發人員指南》中的[線性學習程式演算法](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html)。
在本教學課程中，您將建置一個線性學習程式模型，以預測指定區域的覆蓋類型。您可以在 UCI 機器學習儲存庫的 [Covertype 資料集](https://archive.ics.uci.edu/ml/datasets/covertype)上使用 CREATE MODEL 命令。然後，您可以使用命令建立的預測函數來判斷荒野區域中的覆蓋類型。森林覆蓋類型通常是一個樹種。Redshift ML 將用於建立模型的輸入包括土壤類型、與道路的距離以及荒野區域指定。如需資料集的相關資訊，請參閱 UCI 機器學習儲存庫中的 [Covertype 資料集](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 中 [Covertype 資料集](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)