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의 기계 학습은 하나의 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 예측 함수를 준비할 수 있습니다. 테이블 또는 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 기계 학습 관리를 위한 클러스터 및 구성 설정](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) 및 [Abalone 파일](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 작업이 예측 방법을 학습하는 데 사용하는 기계 학습 레이블 열을 지정합니다. 대상 열 "이탈"은 고객이 여전히 활성 멤버십을 보유하고 있는지 아니면 멤버십을 일시중단했는지를 나타냅니다. 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)를 사용하여 데이터가 암호화됩니다.
AWS KMS 관리형 키(SSE-MMS)로 서버 측 암호화를 사용하여 입력을 암호화할 때 다음 권한을 추가합니다.
```
{
"Effect": "Allow",
"Action": [
"kms:Encrypt"
"kms:Decrypt"
]
}
```
Amazon SageMaker AI 역할에 대한 자세한 내용은 *Amazon SageMaker AI Developer Guide*의 [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-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 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)
+ [What Is Fairness and Model Explainability for Machine Learning Predictions?(기계 학습 예측을 위한 공정성과 모델 설명 가능성이란 무엇입니까?](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 Developer Guide의 [How K-means Clustering Works](https://docs.aws.amazon.com/sagemaker/latest/dg/algo-kmeans-tech-notes.html) 섹션을 참조하세요.
CREATE MODEL 작업을 사용하여 Amazon Redshift 클러스터에서 K-평균 모델을 생성합니다. CREATE MODEL 명령을 사용하여 훈련 데이터를 내보내고, 모델을 훈련하고, 모델을 가져오고, Amazon Redshift 예측 함수를 준비할 수 있습니다. CREATE MODEL 스테이트먼트를 사용하여 테이블 또는 SELECT 작업으로 훈련 데이터를 지정합니다.
이 튜토리얼에서는 전 세계의 세계 뉴스를 모니터링하고 데이터가 매일 매초마다 저장되는 [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 명령을 사용하여 데이터를 7개의 클러스터로 그룹화하는 모델을 생성합니다. 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 기계 학습 사용 비용](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)
+ [What Is Fairness and Model Explainability for Machine Learning Predictions?(기계 학습 예측을 위한 공정성과 모델 설명 가능성이란 무엇입니까?](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 작업으로 훈련 데이터를 지정합니다.
튜토리얼대로 진행하기 위해 온라인 영국 소매업체의 판매 데이터가 들어 있는 [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 dataset](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\$16개월 동안만 활동할 것으로 예상되는 고객 수를 비교합니다. 이 모델은 이러한 고객이 충성도 프로그램에 선택되지 않을 것으로 예측합니다. 그런 다음 쿼리는 간발의 차로 선택되지 못하는 고객의 수와 충성도 프로그램에 선택될 자격이 있는 것으로 예측되는 고객의 수를 비교합니다. 이 쿼리는 충성도 프로그램의 긱준을 낮출지 결정하는 데 사용될 수 있습니다. 또한 프로그램에 간발의 차로 선택되지 않을 것으로 예상되는 고객이 많은지도 판단할 수 있습니다. 그러면 해당 고객에게 활동을 늘려 충성도 프로그램 멤버십을 얻도록 권장할 수 있습니다.
```
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)
+ [What Is Fairness and Model Explainability for Machine Learning Predictions?(기계 학습 예측을 위한 공정성과 모델 설명 가능성이란 무엇입니까?](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 Developer Guide의 [XGBoost algorithm](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html) 섹션을 참조하세요.
`AUTO OFF` 옵션을 사용한 Amazon Redshift ML `CREATE MODEL` 작업은 현재 XGBoost를 `MODEL_TYPE`으로 지원합니다. 사용 사례에 따라 `CREATE MODEL` 명령의 일부로 목적 및 하이퍼파라미터와 같은 관련 정보를 제공할 수 있습니다.
이 튜토리얼에서는 주어진 지폐가 원본인지 위조인지 예측하는 바이너리 분류 문제인 [banknote authentication 데이터 세트](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`을 입력 데이터 세트 및 기타 Redshift ML 아티팩트를 저장할 사용자의 `S3_BUCKET`으로 대체합니다.
```
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)
+ [What Is Fairness and Model Explainability for Machine Learning Predictions?](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로 로드하려면 테이블 세 개를 생성해야 합니다. 데이터 세트는 [Toronto Bike Ridership Data](https://open.toronto.ca/dataset/bike-share-toronto-ridership-data/), [historical weather data](https://climate.weather.gc.ca/historical_data/search_historic_data_e.html), [historical holidays data](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 기계 학습 사용 비용](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)
+ [What Is Fairness and Model Explainability for Machine Learning Predictions?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)
# 튜토리얼: 선형 학습기를 사용하여 회귀 모델 구축
이 튜토리얼에서는 Amazon S3의 데이터로 선형 학습기 모델을 생성하고 Amazon Redshift ML을 사용하여 이 모델로 예측 쿼리를 실행합니다. SageMaker AI 선형 학습기 알고리즘은 회귀 또는 멀티클래스 분류 문제를 해결합니다. 회귀 및 멀티클래스 분류 문제에 대한 자세한 내용은 Amazon SageMaker AI Developer Guide의 [기본 기계 학습 패러다임의 문제 유형](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 Developer Guide의 [Linear Learner Algorithm](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html) 섹션을 참조하세요.
CREATE MODEL 명령을 사용하여 훈련 데이터를 내보내고, 모델을 훈련하고, 모델을 가져오고, Amazon Redshift 예측 함수를 준비할 수 있습니다. CREATE MODEL 스테이트먼트를 사용하여 테이블 또는 SELECT 작업으로 훈련 데이터를 지정합니다.
선형 학습기 모델은 연속형 목표 또는 이산 목표를 최적화합니다. 연속형 목표는 회귀에 사용되고 이산형 변수는 분류에 사용됩니다. 회귀 방법과 같은 일부 방법은 연속형 목표에 대해서만 솔루션을 제공합니다. 선형 학습기 알고리즘은 Naive Bayes 기법과 같은 단순한 하이퍼파라미터 최적화 기법에 비해 속도를 높입니다. 나이브 최적화 기법에서는 각 입력 변수가 독립적이라고 가정합니다. 선형 학습기 알고리즘을 사용하려면 입력의 차원을 나타내는 열과 관측치를 나타내는 행을 제공해야 합니다. 선형 학습기 알고리즘에 대한 자세한 내용은 Amazon SageMaker AI Developer Guide의 [Linear Learner Algorithm](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html) 섹션을 참조하세요.
이 튜토리얼에서는 전복의 나이를 예측하는 선형 학습기 모델을 구축합니다. [Abalone dataset](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 Redshift에서 생성한 `abalone_dataset` 테이블에 Amazon S3의 [Abalone dataset](http://archive.ics.uci.edu/ml/datasets/Abalone)에 있는 샘플 데이터를 복사합니다.
```
COPY abalone_dataset
FROM
's3://redshift-ml-multiclass/abalone.csv' REGION 'us-east-1' IAM_ROLE default CSV IGNOREHEADER 1 NULL AS 'NULL';
```
1. 데이터를 수동으로 분할하면 추가 예측 세트를 할당하여 모델의 정확도를 확인할 수 있습니다. 다음 쿼리는 데이터를 두 세트로 분할합니다. `abalone_training` 테이블은 훈련용이고 `abalone_validation` 테이블은 검증용입니다.
```
CREATE TABLE abalone_training as
SELECT
*
FROM
abalone_dataset
WHERE
mod(id, 10) < 8;
CREATE TABLE abalone_validation as
SELECT
*
FROM
abalone_dataset
WHERE
mod(id, 10) >= 8;
```
## 2단계: 기계 학습 모델 생성
이 단계에서는 CREATE MODEL 스테이트먼트를 사용하여 선형 학습기 알고리즘으로 머신 러닝 모델을 생성합니다.
다음 쿼리는 S3 버킷을 사용하여 CREATE MODEL 작업으로 선형 학습기 모델을 생성합니다. amzn-s3-demo-bucket을 자체 S3 버킷으로 교체합니다.
```
CREATE MODEL model_abalone_ring_prediction
FROM
(
SELECT
Sex,
Length,
Diameter,
Height,
Whole,
Shucked,
Viscera,
Shell,
Rings AS target_label
FROM
abalone_training
) TARGET target_label FUNCTION f_abalone_ring_prediction IAM_ROLE default MODEL_TYPE LINEAR_LEARNER PROBLEM_TYPE REGRESSION OBJECTIVE 'MSE' SETTINGS (
S3_BUCKET 'amzn-s3-demo-bucket',
MAX_RUNTIME 15000
);
```
### 모델 훈련 상태 표시(선택 사항)
SHOW MODEL 명령을 사용하여 모델이 준비되었는지 알 수 있습니다.
다음 쿼리를 사용하여 모델 훈련의 진행 상황을 모니터링합니다.
```
SHOW MODEL model_abalone_ring_prediction;
```
모델이 준비되면 이전 작업의 출력은 다음 예시와 비슷할 것입니다. 출력은 평균 제곱 오차를 나타내는 `validation:mse` 메트릭을 제공합니다. 다음 단계에서 평균 제곱 오차를 사용하여 모델의 정확도를 확인합니다.
```
+--------------------------+----------------------------------------------------------------------------------------------------+
| Model Name | model_abalone_ring_prediction |
+--------------------------+----------------------------------------------------------------------------------------------------+
| Schema Name | public |
| Owner | awsuser |
| Creation Time | Thu, 30.06.2022 18:00:10 |
| Model State | READY |
| validation:mse | 4.168633 |
| Estimated Cost | 4.291608 |
| | |
| TRAINING DATA: | |
| Query | SELECT SEX , LENGTH , DIAMETER , HEIGHT , WHOLE , SHUCKED , VISCERA , SHELL, RINGS AS TARGET_LABEL |
| | FROM ABALONE_TRAINING |
| Target Column | TARGET_LABEL |
| | |
| PARAMETERS: | |
| Model Type | linear_learner |
| Problem Type | Regression |
| Objective | MSE |
| AutoML Job Name | redshiftml-20220630180010947843 |
| Function Name | f_abalone_ring_prediction |
| Function Parameters | sex length diameter height whole shucked viscera shell |
| Function Parameter Types | bpchar float8 float8 float8 float8 float8 float8 float8 |
| IAM Role | default-aws-iam-role |
| S3 Bucket | amzn-s3-demo-bucket |
| Max Runtime | 15000 |
+--------------------------+----------------------------------------------------------------------------------------------------+
```
## 3단계: 모델 검증
1. 다음 예측 쿼리는 평균 제곱 오차 및 제곱 평균 제곱근 오차를 계산하여 `abalone_validation` 데이터 세트에서 모델의 정확도를 검증합니다.
```
SELECT
ROUND(AVG(POWER((tgt_label - predicted), 2)), 2) mse,
ROUND(SQRT(AVG(POWER((tgt_label - predicted), 2))), 2) rmse
FROM
(
SELECT
Sex,
Length,
Diameter,
Height,
Whole,
Shucked,
Viscera,
Shell,
Rings AS tgt_label,
f_abalone_ring_prediction(
Sex,
Length,
Diameter,
Height,
Whole,
Shucked,
Viscera,
Shell
) AS predicted,
CASE
WHEN tgt_label = predicted then 1
ELSE 0
END AS match,
CASE
WHEN tgt_label <> predicted then 1
ELSE 0
END AS nonmatch
FROM
abalone_validation
) t1;
```
이전 쿼리의 출력은 다음 예시와 비슷합니다. 평균 제곱 오차 메트릭의 값은 SHOW MODEL 작업의 출력에 표시되는 `validation:mse` 메트릭과 유사할 것입니다.
```
+-----+--------------------+
| mse | rmse |
+-----+--------------------+
| 5.1 | 2.2600000000000002 |
+-----+--------------------+
```
1. 다음 쿼리를 사용하여 예측 함수에 EXPLAIN\$1MODEL 작업을 실행합니다. 이 작업은 모델 설명 가능성 보고서를 반환합니다. EXPLAIN\$1MODEL 작업에 대한 자세한 내용은 Amazon Redshift 데이터베이스 개발자 안내서의 [EXPLAIN\$1MODEL 함수](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)를 참조하세요.
```
SELECT
EXPLAIN_MODEL ('model_abalone_ring_prediction');
```
다음 정보는 이전 EXPLAIN\$1MODEL 작업에서 생성된 모델 설명 가능성 보고서의 예입니다. 각 입력의 값은 Shapley 값입니다. Shapley 값은 각 입력이 모델 예측에 미치는 영향을 나타내며 값이 높을수록 예측에 더 많은 영향을 미칩니다. 이 예에서 입력 값이 높을수록 전복의 나이를 예측하는 데 더 많은 영향을 미칩니다.
```
{
"explanations": {
"kernel_shap": {
"label0": {
"expected_value" :10.290688514709473,
"global_shap_values": {
"diameter" :0.6856910187882492,
"height" :0.4415323937124035,
"length" :0.21507476107609084,
"sex" :0.448611774505744,
"shell" :1.70426496893776,
"shucked" :2.1181392924386994,
"viscera" :0.342220754059912,
"whole" :0.6711906974084011
}
}
}
},
"version" :"1.0"
};
```
1. 다음 쿼리를 사용하여 모델이 아직 성숙하지 않은 전복에 대해 수행하는 올바른 예측의 백분율을 계산합니다. 미성숙한 전복은 고리가 10개 이하이며 실제 고리 수의 한 고리 내에서까지 정확한 예측이 가능합니다.
```
SELECT
TRUNC(
SUM(
CASE
WHEN ROUND(
f_abalone_ring_prediction(
Sex,
Length,
Diameter,
Height,
Whole,
Shucked,
Viscera,
Shell
),
0
) BETWEEN Rings - 1
AND Rings + 1 THEN 1
ELSE 0
END
) / CAST(COUNT(SHELL) AS FLOAT),
4
) AS prediction_pct
FROM
abalone_validation
WHERE
Rings <= 10;
```
## 관련 주제
Amazon Redshift ML에 대한 자세한 내용은 다음 설명서를 참조하세요.
+ [Amazon Redshift 기계 학습 사용 비용](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)
+ [What Is Fairness and Model Explainability for Machine Learning Predictions?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)
# 튜토리얼: 선형 학습기를 사용하여 다중 클래스 분류 모델 구축
이 튜토리얼에서는 Amazon S3의 데이터로 선형 학습기 모델을 생성하고 Amazon Redshift ML을 사용하여 이 모델로 예측 쿼리를 실행합니다. SageMaker AI 선형 학습기 알고리즘은 회귀 또는 분류 문제를 해결합니다. 회귀 및 멀티클래스 분류 문제에 대한 자세한 내용은 Amazon SageMaker AI Developer Guide의 [기본 기계 학습 패러다임의 문제 유형](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 Developer Guide의 [Linear Learner Algorithm](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 Developer Guide의 [XGBoost algorithm](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html) 섹션을 참조하세요.
선형 학습기 알고리즘을 사용하려면 입력의 차원을 나타내는 열과 관측치를 나타내는 행을 제공해야 합니다. 선형 학습기 알고리즘에 대한 자세한 내용은 Amazon SageMaker AI Developer Guide의 [Linear Learner Algorithm](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html) 섹션을 참조하세요.
이 튜토리얼에서는 특정 영역의 식물 유형을 예측하는 선형 학습기 모델을 구축합니다. UCI Machine Learning Repository에 있는 [Covertype dataset](https://archive.ics.uci.edu/ml/datasets/covertype)에서 CREATE MODEL 명령을 사용합니다. 그런 다음 명령으로 생성한 예측 함수를 사용하여 황야 지역의 식물 유형을 결정합니다. 임상 식물 유형은 일반적으로 나무 중 하나입니다. Redshift ML에서 모델을 생성하는 데 사용할 입력에는 토양 유형, 도로까지의 거리 및 황야 지역 지정이 포함됩니다. 이 데이터 세트에 대한 자세한 내용은 UCI Machine Learning Repository에서 [Covertype Dataset](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 Redshift에서 생성한 `covertype_data` 테이블에 Amazon S3의 [Covertype dataset](https://archive.ics.uci.edu/ml/datasets/covertype)에 있는 샘플 데이터를 복사합니다.
```
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`에서 가장 일반적인 식물 유형을 예측합니다. 이 데이터 세트에는 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. 다음 쿼리는 하나의 황야 지역에서 가장 일반적인 식물 유형을 보여줍니다. 쿼리에는 해당 식물 유형의 양과 해당 식물 유형의 황야 지역이 표시됩니다.
```
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)
+ [What Is Fairness and Model Explainability for Machine Learning Predictions?(기계 학습 예측을 위한 공정성과 모델 설명 가능성이란 무엇입니까?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html))