Amazon Redshift は、パッチ 198 以降、新しい 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 の機械学習は、1 つの SQL コマンドでモデルをトレーニングします。Amazon Redshift は、Amazon SageMaker AI でトレーニングジョブを自動的に開始し、モデルを生成します。モデルが作成されると、そのモデルの予測関数を使用して Amazon Redshift で予測を実行できます。
これらのチュートリアルのステップに従って、Amazon Redshift ML の特徴について学習します。
+ [チュートリアル: カスタマーチャーンモデルの構築](tutorial_customer_churn.md) - このチュートリアルでは、Amazon Redshift ML を使用して CREATE MODEL コマンドでカスタマーチャーンモデルを作成し、ユーザーシナリオの予測クエリを実行します。次に、CREATE MODEL コマンドが生成する SQL 関数を使用してクエリを実装します。
+ [チュートリアル: K-means クラスタリングモデルの構築](tutorial_k-means_clustering.md) - このチュートリアルでは、Amazon Redshift ML を使用して、[K-means アルゴリズム](url-sm-dev;k-means.html)に基づく機械学習モデルを作成、トレーニングおよびデプロイします。
+ [チュートリアル: 複数クラス分類モデルの構築](tutorial_multi-class_classification.md) - このチュートリアルでは、Amazon Redshift ML を使用して、複数クラス分類の問題を解決する機械学習モデルを作成します。多クラス分類アルゴリズムは、データポイントを 3 つ以上のクラスのいずれかに分類します。次に、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 予測関数の準備を行うことができます。トレーニングデータをテーブルまたは SELECT ステートメントとして指定するには、CREATE MODEL ステートメントを使用します。
この例では、履歴情報を使用して、携帯電話事業者のカスタマーチャーンに対して機械学習モデルを構築します。まず、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 commands (SQL コマンド)](https://s3.amazonaws.com/redshift-downloads/redshift-ml/tutorial-scripts/redshift-ml-tutorial.sql)]、[[Customer activity file (顧客のアクティビティファイル)](https://s3.amazonaws.com/redshift-downloads/redshift-ml/customer_activity/customer_activity.csv)]、および [[Abalone file (アワビファイル)](https://s3.amazonaws.com/redshift-downloads/redshift-ml/abalone_xg/abalone.csv)] をダウンロードします。
+ Amazon S3 用の AWS CLI を使用して、次のコマンドを実行します。独自のターゲットパスを使用できます。
```
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 オペレーションが予測する方法を学習するために使用する機械学習ラベルである列を指定します。ターゲット列の「churn」は、顧客がまだ有効なメンバーシップを持っているか、メンバーシップを一時停止しているかを示します。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` です。予測関数の入力引数は、`state` には varchar、`account_length` には integer など、機能のタイプに対応しています。予測関数の出力は、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-means クラスタリングモデルの構築
このチュートリアルでは、Amazon Redshift ML を使用して、[k-means アルゴリズム](url-sm-dev;k-means.html)に基づく機械学習モデルを作成、トレーニングおよびデプロイします。このアルゴリズムは、データ内でグループを検出する際にクラスタリングで発生する問題を解決します。K-means は、まだラベル付けされていないデータのグループ化に役立ちます。K-means クラスタリングの詳細については、「Amazon SageMaker AI デベロッパーガイド」の「[K-means クラスタリングの仕組み](https://docs.aws.amazon.com/sagemaker/latest/dg/algo-kmeans-tech-notes.html)」を参照してください。
CREATE MODEL オペレーションを使用して、Amazon Redshift クラスターから K-means モデルを作成します。CREATE MODEL コマンドを使用して、トレーニングデータのエクスポート、モデルのトレーニング、モデルのインポート、Amazon Redshift 予測関数の準備を行うことができます。トレーニングデータをテーブルまたは SELECT ステートメントとして指定するには、CREATE MODEL オペレーションを使用します。
このチュートリアルでは、K-means を[イベント、言語、トーンのグローバルデータベース (GDELT)](https://aws.amazon.com/public-datasets/gdelt/) データセットで使用し、世界中のニュースを監視して、データを日々秒単位で保存します K-means は、似たようなトーン、俳優、または場所のイベントをグループ化します。データは、Amazon Simple Storage Service の 2 つの異なるフォルダに複数のファイルで保存されます。フォルダは、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 コマンドを使用して、データを 7 つのクラスターにグループ化するモデルを作成します。K 値は、データポイントが分割されるクラスターの数です。このモデルは、データポイントをそれらが互いに類似しているクラスターに分類します。データポイントをグループにクラスタリングすることにより、K-Means アルゴリズムは最適なクラスター中心を反復的に決定します。次に、アルゴリズムは各データポイントを最も近いクラスター中心に割り当てます。最も近い中心が同じである各メンバーは、同じグループに属します。1 つのグループには、可能な限り互いに類似した (かつ、他のグループのメンバーとは可能な限り相違する) メンバーが集められます。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;
```
### クラスターのデータポイントに関する情報を表示する
次のクエリを使用して、5 番目のクラスターに割り当てられたポイントのデータを返します。選択した記事には 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;
```
### 同じ人種コードの俳優のイベントに関するデータを表示する
次のクエリは、肯定的なトーンのイベントについて書かれた記事数を係数します。また、このクエリでは、2 人の俳優の民族コードが同じである必要があり、各イベントが割り当てられているクラスターが返されます。
```
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 機械学習を使用するためのコスト](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 を使用して、複数クラス分類の問題を解決する機械学習モデルを作成します。多クラス分類アルゴリズムは、データポイントを 3 つ以上のクラスのいずれかに分類します。次に、CREATE MODEL コマンドが生成する SQL 関数を使用してクエリを実装します。
CREATE MODEL コマンドを使用して、トレーニングデータのエクスポート、モデルのトレーニング、モデルのインポート、Amazon Redshift 予測関数の準備を行うことができます。トレーニングデータをテーブルまたは SELECT ステートメントとして指定するには、CREATE MODEL オペレーションを使用します。
このチュートリアルでは、パブリックデータセットの [E-Commerce Sales Forecast](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. 次のクエリは、サンプルデータを [E-Commerce Sales Forecast データセット](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 ステートメントを使用して、データをトレーニング、検証、および予測の 3 つのセットに分割します。
```
--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 機械学習を使用するためのコスト](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)」を参照してください。
`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) を使用する次のクエリを実行します。
次のクエリは、2 つのテーブルを作成し、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` メトリクスは、小数点以下 6 桁までのモデルの精度の測定単位です。値 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 機械学習を使用するためのコスト](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 を使用して、1 日の任意の時間にトロント市の自転車シェアサービスを利用する人の数を予測するリグレッションモデルを構築します。モデルの入力には、祝日と気象条件が含まれます。この問題には数値的な結果が必要なため、リグレッションモデルを使用します。
CREATE MODEL コマンドを使用して、トレーニングデータをエクスポートし、モデルをトレーニングし、Amazon Redshift で SQL 関数として使用できるようにします。トレーニングデータをテーブルまたは SELECT ステートメントとして指定するには、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) を使用する次のクエリを実行します。
1. 3 つのパブリックデータセットを Amazon Redshift に読み込むには、3 つのテーブルを作成する必要があります。データセットは[トロントバイクライダーシップデータ](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` という名前の 2 つの新しいビューを作成することによってテーブルを単純化します。
```
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 機械学習を使用するためのコスト](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 予測関数の準備を行うことができます。トレーニングデータをテーブルまたは SELECT ステートメントとして指定するには、CREATE MODEL オペレーションを使用します。
線形学習モデルは、連続的な目標または離散的な目標のいずれかを最適化します。連続的な目標はリグレッションに使用され、離散変数は分類に使用されます。リグレッション法など、一部の方法は、連続的な目標のみに対する解を提供します。線形学習アルゴリズムは、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. データを手動で分割することにより、追加の予測セットを割り当てることでモデルの精度を検証できます。次のクエリは、データを 2 つのセットに分割します。`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 個以下で、正確な予測では、実際の輪の数が 1 輪以内で高精度となります。
```
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 機械学習を使用するためのコスト](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 予測関数の準備を行うことができます。トレーニングデータをテーブルまたは SELECT ステートメントとして指定するには、CREATE MODEL オペレーションを使用します。
線形学習モデルは、連続的な目標または離散的な目標のいずれかを最適化します。連続的な目標はリグレッションに使用され、離散変数は分類に使用されます。リグレッション法など、一部の方法は、連続的な目標のみに対する解を提供します。線形学習アルゴリズムは、Naive Bayes 手法などの単純なハイパーパラメータ最適化手法より高速です。単純な最適化手法では、各入力変数は独立していると仮定します。線形学習アルゴリズムは、多数のモデルを並列でトレーニングし、最も最適化されたモデルを選択します。同様のアルゴリズムが XGBoost です。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 Machine Learning リポジトリの [Covertype データセット](https://archive.ics.uci.edu/ml/datasets/covertype) で CREATE MODEL コマンドを使用します。次に、コマンドで作成された予測関数を使用して、荒野地域の植生の種類を特定します。森林の種類の種類は、通常、樹木の一種です。Redshift ML がモデルの作成に使用する入力には、土壌タイプ、道路までの距離、および荒野地域の指定が含まれます。データセットの詳細については、UCI Machine Learning リポジトリの [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. データを手動で分割することにより、追加のテストセットを割り当てることでモデルの精度を検証できます。次のクエリは、データを 2 つのセットに分割します。`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` の最も一般的な植生の種類を予測します。このデータセットには、4 つの荒野地域と 7 つの植生の種類が含まれています。荒野地域は複数の植生の種類が存在する場合があります。
```
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. 次のクエリは、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 機械学習を使用するためのコスト](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)