Amazon Redshift tidak akan lagi mendukung pembuatan Python UDFs baru mulai Patch 198. Python yang ada UDFs akan terus berfungsi hingga 30 Juni 2026. Untuk informasi lebih lanjut, lihat [posting blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Tutorial untuk Amazon Redshift ML
Anda dapat menggunakan Amazon Redshift ML untuk melatih model pembelajaran mesin menggunakan pernyataan SQL, lalu memanggil model dalam kueri SQL untuk prediksi. Pembelajaran mesin di Amazon Redshift melatih model dengan satu perintah SQL. Amazon Redshift secara otomatis meluncurkan pekerjaan pelatihan di Amazon SageMaker AI dan menghasilkan model. Setelah model dibuat, Anda dapat melakukan prediksi di Amazon Redshift menggunakan fungsi prediksi model.
Ikuti langkah-langkah dalam tutorial ini untuk mempelajari tentang fitur Amazon Redshift ML:
+ [Tutorial: Membangun model churn pelanggan](tutorial_customer_churn.md)— Dalam tutorial ini, Anda menggunakan Amazon Redshift MLuntuk membuat model churn pelanggan dengan perintah CREATE MODEL, dan menjalankan query prediksi untuk skenario pengguna. Kemudian, Anda mengimplementasikan kueri menggunakan fungsi SQL yang dihasilkan oleh perintah CREATE MODEL.
+ [Tutorial: Membangun model pengelompokan K-means](tutorial_k-means_clustering.md)[— Dalam tutorial ini, Anda menggunakan Amazon Redshift MLuntuk membuat, melatih, dan menerapkan model pembelajaran mesin berdasarkan algoritma K-means.](url-sm-dev;k-means.html)
+ [Tutorial: Membangun model klasifikasi multi-kelas](tutorial_multi-class_classification.md)— Dalam tutorial ini, Anda menggunakan Amazon Redshift MLuntuk membuat model pembelajaran mesin yang memecahkan masalah klasifikasi multi-kelas. Algoritma klasifikasi multi-kelas mengklasifikasikan titik data menjadi salah satu dari tiga kelas atau lebih. Kemudian, Anda mengimplementasikan kueri menggunakan fungsi SQL yang dihasilkan oleh perintah CREATE MODEL.
+ [Tutorial: Membangun XGBoost model](tutorial_xgboost.md)— Dalam tutorial ini, Anda membuat model dengan data dari Amazon S3 dan menjalankan kueri prediksi dengan model menggunakan Amazon Redshift ML. XGBoost Algoritma ini adalah implementasi yang dioptimalkan dari algoritma pohon yang ditingkatkan gradien.
+ [Tutorial: Membangun model regresi](tutorial_regression.md)— Dalam tutorial ini, Anda menggunakan Amazon Redshift MLuntuk membuat model regresi pembelajaran mesin dan menjalankan kueri prediksi pada model. Model regresi memungkinkan Anda memprediksi hasil numerik, seperti harga rumah, atau berapa banyak orang yang akan menggunakan layanan penyewaan sepeda kota.
+ [Tutorial: Membangun model regresi dengan pelajar linier](tutorial_linear_learner_regression.md)— Dalam tutorial ini, Anda membuat model pembelajar linier dengan data dari Amazon S3 dan menjalankan kueri prediksi dengan model menggunakan Amazon Redshift ML. Algoritma pembelajar linier SageMaker AI memecahkan masalah regresi atau klasifikasi multi-kelas.
+ [Tutorial: Membangun model klasifikasi multi-kelas dengan pelajar linier](tutorial_linear_learner_multi-class_classification.md)— Dalam tutorial ini, Anda membuat model pembelajar linier dengan data dari Amazon S3, dan kemudian menjalankan kueri prediksi dengan model menggunakan Amazon Redshift ML. Algoritma pembelajar linier SageMaker AI memecahkan masalah regresi atau klasifikasi.
# Tutorial: Membangun model churn pelanggan
Dalam tutorial ini, Anda menggunakan Amazon Redshift MLuntuk membuat model churn pelanggan dengan perintah CREATE MODEL, dan menjalankan query prediksi untuk skenario pengguna. Kemudian, Anda mengimplementasikan kueri menggunakan fungsi SQL yang dihasilkan oleh perintah CREATE MODEL.
Anda dapat menggunakan perintah CREATE MODEL sederhana untuk mengekspor data pelatihan, melatih model, mengimpor model, dan menyiapkan fungsi prediksi Amazon Redshift. Gunakan pernyataan CREATE MODEL untuk menentukan data pelatihan baik sebagai tabel atau pernyataan SELECT.
Contoh ini menggunakan informasi historis untuk membangun model pembelajaran mesin dari churn pelanggan operator seluler. Pertama, SageMaker AI melatih model pembelajaran mesin Anda dan kemudian menguji model Anda menggunakan informasi profil pelanggan yang sewenang-wenang. Setelah model divalidasi, Amazon SageMaker AI menyebarkan model dan fungsi prediksi ke Amazon Redshift. Anda dapat menggunakan fungsi prediksi untuk memprediksi apakah pelanggan akan churn atau tidak.
## Contoh kasus penggunaan
Anda dapat memecahkan masalah klasifikasi biner lainnya menggunakan Amazon Redshift ML, seperti memprediksi apakah prospek penjualan akan ditutup atau tidak. Anda juga bisa memprediksi apakah transaksi keuangan itu curang atau tidak.
**Tugas**
+ Prasyarat
+ Langkah 1: Muat data dari Amazon S3 ke Amazon Redshift
+ Langkah 2: Buat model pembelajaran mesin
+ Langkah 3: Lakukan prediksi dengan model
## Prasyarat
Untuk menyelesaikan tutorial ini, Anda harus memiliki prasyarat berikut:
+ Anda harus menyiapkan klaster Amazon Redshift untuk Amazon Redshift Ml. Untuk melakukannya, gunakan dokumentasi untuk [Cluster dan konfigurasikan penyiapan untuk administrasi Amazon Redshift ML.](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html)
+ Cluster Amazon Redshift yang Anda gunakan untuk membuat model, dan bucket Amazon S3 yang Anda gunakan untuk mementaskan data pelatihan dan menyimpan artefak model harus berada di Wilayah yang sama. AWS
+ Untuk mengunduh perintah SQL dan kumpulan data sampel yang digunakan dalam dokumentasi ini, lakukan salah satu hal berikut:
+ Unduh [perintah SQL](https://s3.amazonaws.com/redshift-downloads/redshift-ml/tutorial-scripts/redshift-ml-tutorial.sql), [file aktivitas Pelanggan, dan file](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).
+ Menggunakan AWS CLI untuk Amazon S3, jalankan perintah berikut. Anda dapat menggunakan jalur target Anda sendiri.
```
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
```
## Langkah 1: Muat data dari Amazon S3 ke Amazon Redshift
Gunakan [editor kueri Amazon Redshift v2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) untuk mengedit dan menjalankan kueri serta memvisualisasikan hasil.
Menjalankan kueri berikut akan membuat tabel bernama `customer_activity` dan menyerap kumpulan data sampel dari 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;
```
## Langkah 2: Buat model pembelajaran mesin
Churn adalah masukan target kami dalam model ini. Semua input lain untuk model adalah atribut yang membantu membuat fungsi untuk memprediksi churn.
Contoh berikut menggunakan operasi CREATE MODEL untuk memberikan model yang memprediksi apakah pelanggan akan aktif, menggunakan input seperti usia pelanggan, kode pos, pengeluaran, dan kasus. Dalam contoh berikut, ganti amzn-s3-demo-bucket dengan bucket Amazon S3 Anda sendiri.
```
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'
);
```
Query SELECT dalam contoh sebelumnya membuat data pelatihan. Klausa TARGET menentukan kolom mana yang merupakan label pembelajaran mesin yang digunakan operasi CREATE MODEL untuk mempelajari cara memprediksi. Kolom target “churn” menunjukkan apakah pelanggan masih memiliki keanggotaan aktif atau telah menangguhkan keanggotaan. Bidang S3\$1BUCKET adalah nama bucket Amazon S3 yang sebelumnya Anda buat. Bucket Amazon S3 digunakan untuk berbagi data pelatihan dan artefak antara Amazon Redshift dan Amazon AI. SageMaker Kolom yang tersisa adalah fitur yang digunakan untuk prediksi.
Untuk ringkasan sintaks dan fitur kasus penggunaan dasar perintah CREATE MODEL, lihat [Simple CREATE MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_create_model_use_cases.html#r_simple_create_model).
### Tambahkan izin untuk enkripsi sisi server (opsional)
Amazon Redshift secara default menggunakan Amazon SageMaker AI Autopilot untuk pelatihan. Secara khusus, Amazon Redshift mengekspor data pelatihan dengan aman ke bucket Amazon S3 yang ditentukan pelanggan. Jika Anda tidak menentukan`KMS_KEY_ID`, maka data dienkripsi menggunakan enkripsi sisi server SSE-S3 secara default.
Saat Anda mengenkripsi input menggunakan enkripsi sisi server dengan kunci AWS KMS terkelola (SSE-MMS), tambahkan izin berikut:
```
{
"Effect": "Allow",
"Action": [
"kms:Encrypt"
"kms:Decrypt"
]
}
```
Untuk informasi selengkapnya tentang peran Amazon SageMaker AI, lihat [peran Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html) di *Panduan Pengembang Amazon SageMaker AI*.
### Periksa status pelatihan model (opsional)
Anda dapat menggunakan perintah SHOW MODEL untuk mengetahui kapan model Anda siap.
Gunakan operasi berikut untuk memeriksa status model.
```
SHOW MODEL customer_churn_auto_model;
```
Berikut ini adalah contoh output dari operasi sebelumnya.
```
+--------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------+
| 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 |
+--------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------+
```
Ketika pelatihan model selesai, `model_state` variabel menjadi`Model is Ready`, dan fungsi prediksi menjadi tersedia.
## Langkah 3: Lakukan prediksi dengan model
Anda dapat menggunakan pernyataan SQL untuk melihat prediksi yang dibuat oleh model prediksi. Dalam contoh ini, fungsi prediksi yang dibuat oleh operasi CREATE MODEL diberi nama`ml_fn_customer_churn_auto`. Argumen input untuk fungsi prediksi sesuai dengan jenis fitur, seperti varchar untuk `state` dan integer untuk. `account_length` Output dari fungsi prediksi adalah tipe yang sama dengan kolom TARGET dari pernyataan CREATE MODEL.
1. Anda melatih model pada data dari sebelum 2020-01-01, jadi sekarang Anda menggunakan fungsi prediksi pada set pengujian. Kueri berikut menampilkan prediksi apakah pelanggan yang mendaftar setelah 2020-01-01 akan melalui churn atau tidak.
```
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. Contoh berikut menggunakan fungsi prediksi yang sama untuk kasus penggunaan yang berbeda. Dalam hal ini, Amazon Redshift memprediksi proporsi churner dan non-churner di antara pelanggan dari berbagai negara bagian di mana tanggal pencatatan lebih besar dari 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. Contoh berikut menggunakan fungsi prediksi untuk kasus penggunaan memprediksi persentase pelanggan yang melakukan churn dalam suatu keadaan. Dalam hal ini, Amazon Redshift memprediksi persentase churn di mana tanggal rekor lebih besar dari 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;
```
## Topik terkait
Untuk informasi selengkapnya tentang Amazon Redshift ML, lihat dokumentasi berikut:
+ [Biaya untuk menggunakan Amazon RedShiftMl](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [BUAT perintah MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [Fungsi EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)
Untuk informasi selengkapnya tentang pembelajaran mesin, lihat dokumentasi berikut:
+ [Ikhtisar pembelajaran mesin](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [Pembelajaran mesin untuk pemula dan ahli](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [Apa Keadilan dan Penjelasan Model untuk Prediksi Machine Learning?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)
# Tutorial: Membangun model pengelompokan K-means
[Dalam tutorial ini, Anda menggunakan Amazon Redshift ML untuk membuat, melatih, dan menerapkan model pembelajaran mesin berdasarkan algoritma K-means.](url-sm-dev;k-means.html) Algoritma ini memecahkan masalah pengelompokan di mana Anda ingin menemukan pengelompokan dalam data. K-means membantu dalam mengelompokkan data yang belum diberi label. Untuk mempelajari lebih lanjut tentang pengelompokan K-means, lihat [Cara Kerja K-Means Clustering di Panduan Pengembang](https://docs.aws.amazon.com/sagemaker/latest/dg/algo-kmeans-tech-notes.html) Amazon SageMaker AI.
Anda akan menggunakan operasi CREATE MODEL untuk membuat model K-means dari cluster Amazon Redshift. Anda dapat menggunakan perintah CREATE MODEL untuk mengekspor data pelatihan, melatih model, mengimpor model, dan menyiapkan fungsi prediksi Amazon Redshift. Gunakan operasi CREATE MODEL untuk menentukan data pelatihan baik sebagai tabel atau pernyataan SELECT.
Dalam tutorial ini, Anda menggunakan K-means pada dataset [Global Database of Events, Language, and Tone (GDELT)](https://aws.amazon.com/public-datasets/gdelt/), yang memantau berita dunia di seluruh dunia, dan data disimpan setiap detik setiap hari. K-means akan mengelompokkan acara yang memiliki nada, aktor, atau lokasi yang sama. Data disimpan sebagai beberapa file di Amazon Simple Storage Service, dalam dua folder berbeda. Folder tersebut bersejarah, yang mencakup tahun 1979-2013, dan pembaruan harian, yang mencakup tahun 2013 dan setelahnya. Untuk contoh ini, kami menggunakan format historis dan membawa data 1979.
## Contoh kasus penggunaan
Anda dapat memecahkan masalah pengelompokan lainnya dengan Amazon Redshift ML, seperti mengelompokkan pelanggan yang memiliki kebiasaan menonton serupa pada layanan streaming. Anda juga dapat menggunakan Redshift ML untuk memprediksi jumlah optimal pusat pengiriman untuk layanan pengiriman.
**Tugas**
+ Prasyarat
+ Langkah 1: Muat data dari Amazon S3 ke Amazon Redshift
+ Langkah 2: Buat model pembelajaran mesin
+ Langkah 3: Lakukan prediksi dengan model
## Prasyarat
Untuk menyelesaikan tutorial ini, Anda harus menyelesaikan [pengaturan Administratif](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html) untuk Amazon Redshift Ml.
## Langkah 1: Muat data dari Amazon S3 ke Amazon Redshift
1. Gunakan [editor kueri Amazon Redshift v2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) untuk menjalankan kueri berikut. Kueri menjatuhkan `gdelt_data` tabel dalam skema publik jika ada dan membuat tabel dengan nama yang sama dalam skema publik.
```
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. Query berikut memuat data sampel ke dalam `gdelt_data` tabel.
```
COPY gdelt_data
FROM 's3://gdelt-open-data/events/1979.csv'
REGION 'us-east-1'
IAM_ROLE default
CSV
DELIMITER '\t';
```
### Periksa data pelatihan (opsional)
Untuk melihat data apa yang akan dilatih model Anda, gunakan kueri berikut.
```
SELECT
AvgTone,
EventCode,
NumArticles,
Actor1Geo_Lat,
Actor1Geo_Long,
Actor2Geo_Lat,
Actor2Geo_Long
FROM
gdelt_data LIMIT 100;
```
## Langkah 2: Buat model pembelajaran mesin
Contoh berikut menggunakan perintah CREATE MODEL untuk membuat model yang mengelompokkan data menjadi tujuh cluster. Nilai K adalah jumlah cluster tempat titik data Anda dibagi menjadi. Model ini mengklasifikasikan titik data Anda ke dalam cluster di mana titik data lebih mirip satu sama lain. Dengan mengelompokkan titik data ke dalam kelompok, algoritma K-Means secara iteratif menentukan pusat cluster terbaik. Algoritma kemudian menetapkan setiap titik data ke pusat cluster terdekat. Anggota terdekat dengan pusat cluster yang sama termasuk dalam grup yang sama. Anggota kelompok semirip mungkin dengan anggota lain dalam kelompok yang sama, dan berbeda mungkin dari anggota kelompok lain. Nilai K bersifat subjektif dan bergantung pada metode yang mengukur kesamaan antar titik data. Anda dapat mengubah nilai K untuk menghaluskan ukuran cluster jika cluster tidak terdistribusi secara merata.
Dalam contoh berikut, ganti amzn-s3-demo-bucket dengan bucket Amazon S3 Anda sendiri.
```
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');
```
### Periksa status pelatihan model (opsional)
Anda dapat menggunakan perintah SHOW MODEL untuk mengetahui kapan model Anda siap.
Untuk memeriksa status model, gunakan operasi SHOW MODEL berikut dan temukan apakah `Model State` ada`Ready`.
```
SHOW MODEL NEWS_DATA_CLUSTERS;
```
Ketika model siap, output dari operasi sebelumnya harus menunjukkan bahwa `Model State` adalah`Ready`. Berikut ini adalah contoh output dari operasi 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 |
+--------------------------+------------------------------------------------------------------------------------------------------+
```
## Langkah 3: Lakukan prediksi dengan model
### Identifikasi cluster
Anda dapat menemukan pengelompokan diskrit yang diidentifikasi dalam data oleh model Anda, atau dikenal sebagai cluster. Cluster adalah kumpulan titik data yang lebih dekat ke pusat klaster daripada pusat cluster lainnya. Karena nilai K mewakili jumlah cluster dalam model, itu juga mewakili jumlah pusat cluster. Kueri berikut mengidentifikasi cluster dengan menunjukkan cluster yang terkait dengan masing-masing. `globaleventid`
```
SELECT
globaleventid,
news_monitoring_cluster (
AvgTone,
EventCode,
NumArticles,
Actor1Geo_Lat,
Actor1Geo_Long,
Actor2Geo_Lat,
Actor2Geo_Long
) AS cluster
FROM
gdelt_data;
```
### Periksa distribusi data
Anda dapat memeriksa distribusi data di seluruh cluster untuk melihat apakah nilai K yang Anda pilih menyebabkan data terdistribusi agak merata. Gunakan kueri berikut untuk menentukan apakah data didistribusikan secara merata di seluruh cluster Anda.
```
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;
```
Perhatikan bahwa Anda dapat mengubah nilai K untuk menghaluskan ukuran cluster jika cluster tidak terdistribusi secara merata.
### Tentukan pusat cluster
Titik data lebih dekat ke pusat klaster daripada ke pusat cluster lainnya. Dengan demikian, menemukan pusat cluster membantu Anda menentukan cluster.
Jalankan kueri berikut untuk menentukan pusat cluster berdasarkan jumlah artikel berdasarkan kode acara.
```
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;
```
### Menampilkan informasi tentang titik data dalam klaster
Gunakan kueri berikut untuk mengembalikan data untuk poin yang ditetapkan ke cluster kelima. Artikel yang dipilih harus memiliki dua aktor.
```
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;
```
### Tampilkan data tentang peristiwa dengan aktor dari kode etnis yang sama
Kueri berikut menghitung jumlah artikel yang ditulis tentang peristiwa dengan nada positif. Kueri juga mengharuskan kedua aktor memiliki kode etnis yang sama dan mengembalikan cluster mana yang ditugaskan untuk setiap peristiwa.
```
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;
```
## Topik terkait
Untuk informasi selengkapnya tentang Amazon Redshift ML, lihat dokumentasi berikut:
+ [Biaya untuk menggunakan Amazon Redshift ML](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [OPERASI BUAT MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [Fungsi EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)
Untuk informasi selengkapnya tentang pembelajaran mesin, lihat dokumentasi berikut:
+ [Ikhtisar pembelajaran mesin](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [Pembelajaran mesin untuk pemula dan ahli](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [Apa Keadilan dan Penjelasan Model untuk Prediksi Machine Learning?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)
# Tutorial: Membangun model klasifikasi multi-kelas
Dalam tutorial ini, Anda menggunakan Amazon Redshift ML untuk membuat model pembelajaran mesin yang memecahkan masalah klasifikasi multi-kelas. Algoritma klasifikasi multi-kelas mengklasifikasikan titik data menjadi salah satu dari tiga kelas atau lebih. Kemudian, Anda mengimplementasikan kueri menggunakan fungsi SQL yang dihasilkan oleh perintah CREATE MODEL.
Anda dapat menggunakan perintah CREATE MODEL untuk mengekspor data pelatihan, melatih model, mengimpor model, dan menyiapkan fungsi prediksi Amazon Redshift. Gunakan operasi CREATE MODEL untuk menentukan data pelatihan baik sebagai tabel atau pernyataan SELECT.
Untuk mengikuti tutorial, Anda menggunakan dataset publik [E-Commerce Sales Forecast](https://www.kaggle.com/allunia/e-commerce-sales-forecast), yang mencakup data penjualan pengecer Inggris online. Model yang Anda hasilkan akan menargetkan pelanggan paling aktif untuk program loyalitas pelanggan khusus. Dengan klasifikasi multi-kelas, Anda dapat menggunakan model untuk memprediksi berapa bulan pelanggan akan aktif selama periode 13 bulan. Fungsi prediksi menunjuk pelanggan yang diprediksi akan aktif selama 7 bulan atau lebih untuk masuk ke program.
## Contoh kasus penggunaan
Anda dapat memecahkan masalah klasifikasi multi-kelas lainnya dengan Amazon Redshift ML, seperti memprediksi produk terlaris dari lini produk. Anda juga dapat memprediksi buah mana yang terkandung dalam gambar, seperti memilih apel atau pir atau jeruk.
**Tugas**
+ Prasyarat
+ Langkah 1: Muat data dari Amazon S3 ke Amazon Redshift
+ Langkah 2: Buat model pembelajaran mesin
+ Langkah 3: Lakukan prediksi dengan model
## Prasyarat
Untuk menyelesaikan tutorial ini, Anda harus menyelesaikan [pengaturan Administratif](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html) untuk Amazon Redshift Ml.
## Langkah 1: Muat data dari Amazon S3 ke Amazon Redshift
Gunakan [editor kueri Amazon Redshift v2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) untuk menjalankan kueri berikut. Kueri ini memuat data sampel ke Amazon Redshift.
1. Query berikut membuat tabel bernama`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. Kueri berikut menyalin data sampel dari [dataset E-Commerce Sales Forecast](https://www.kaggle.com/allunia/e-commerce-sales-forecast) ke dalam `ecommerce_sales` tabel.
```
COPY ecommerce_sales
FROM
's3://redshift-ml-multiclass/ecommerce_data.txt'
IAM_ROLE default
DELIMITER '\t'
IGNOREHEADER 1
REGION 'us-east-1'
MAXERROR 100;
```
### Membagi data
Saat Anda membuat model di Amazon Redshift ML, SageMaker AI secara otomatis membagi data Anda menjadi set pelatihan dan pengujian, sehingga SageMaker AI dapat menentukan akurasi model. Dengan memisahkan data secara manual pada langkah ini, Anda akan dapat memverifikasi keakuratan model dengan mengalokasikan set prediksi tambahan.
Gunakan pernyataan SQL berikut untuk membagi data menjadi tiga set untuk pelatihan, validasi, dan prediksi.
```
--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);
```
## Langkah 2: Buat model pembelajaran mesin
Pada langkah ini, Anda menggunakan pernyataan CREATE MODEL untuk membuat model pembelajaran mesin Anda menggunakan klasifikasi multi-kelas.
Kueri berikut membuat model klasifikasi multi-kelas dengan set pelatihan menggunakan operasi CREATE MODEL. Ganti amzn-s3-demo-bucket dengan bucket Amazon S3 Anda sendiri.
```
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
);
```
Dalam kueri ini, Anda menentukan jenis masalah sebagai`Multiclass_Classification`. Target yang Anda prediksi untuk model tersebut adalah`nbr_months_active`. Ketika SageMaker AI selesai melatih model, itu menciptakan fungsi`predict_customer_activity`, yang akan Anda gunakan untuk membuat prediksi di Amazon Redshift.
### Tampilkan status pelatihan model (opsional)
Anda dapat menggunakan perintah SHOW MODEL untuk mengetahui kapan model Anda siap.
Gunakan kueri berikut untuk mengembalikan berbagai metrik model, termasuk status model dan akurasi.
```
SHOW MODEL ecommerce_customer_activity;
```
Ketika model siap, output dari operasi sebelumnya harus menunjukkan bahwa `Model State` adalah`Ready`. Berikut ini adalah contoh output dari operasi 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 |
+--------------------------+-----------------------------------------------------------------------------------------------+
```
## Langkah 3: Lakukan prediksi dengan model
Kueri berikut menunjukkan pelanggan mana yang memenuhi syarat untuk program loyalitas pelanggan Anda. Jika model memprediksi bahwa pelanggan akan aktif setidaknya selama tujuh bulan, maka model memilih pelanggan untuk program loyalitas.
```
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;
```
### Jalankan kueri prediksi terhadap data validasi (opsional)
Jalankan kueri prediksi berikut terhadap data validasi untuk melihat tingkat akurasi model.
```
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;
```
### Memprediksi berapa banyak pelanggan yang melewatkan entri (opsional)
Kueri berikut membandingkan jumlah pelanggan yang diprediksi aktif hanya selama 5 atau 6 bulan. Model memprediksi bahwa pelanggan ini akan kehilangan program loyalitas. Kueri kemudian membandingkan jumlah yang hampir tidak ketinggalan program dengan nomor yang diperkirakan memenuhi syarat untuk program loyalitas. Kueri ini dapat digunakan untuk menginformasikan keputusan apakah akan menurunkan ambang batas untuk program loyalitas. Anda juga dapat menentukan apakah ada sejumlah besar pelanggan yang diperkirakan hampir tidak akan melewatkan program. Anda kemudian dapat mendorong pelanggan tersebut untuk meningkatkan aktivitas mereka untuk mendapatkan keanggotaan program loyalitas.
```
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);
```
## Topik terkait
Untuk informasi selengkapnya tentang Amazon Redshift ML, lihat dokumentasi berikut:
+ [Biaya untuk menggunakan Amazon Redshift ML](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [OPERASI BUAT MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [Fungsi EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)
Untuk informasi selengkapnya tentang pembelajaran mesin, lihat dokumentasi berikut:
+ [Ikhtisar pembelajaran mesin](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [Pembelajaran mesin untuk pemula dan ahli](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [Apa Keadilan dan Penjelasan Model untuk Prediksi Machine Learning?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)
# Tutorial: Membangun XGBoost model
Dalam tutorial ini, Anda membuat model dengan data dari Amazon S3 dan menjalankan kueri prediksi dengan model menggunakan Amazon Redshift ML. XGBoost Algoritma ini adalah implementasi yang dioptimalkan dari algoritma pohon yang ditingkatkan gradien. XGBoost menangani lebih banyak tipe data, hubungan, dan distribusi daripada algoritma pohon yang ditingkatkan gradien lainnya. Anda dapat menggunakan XGBoost untuk regresi, klasifikasi biner, klasifikasi multi-kelas, dan masalah peringkat. Untuk informasi selengkapnya tentang XGBoost algoritme, lihat [XGBoostalgoritme](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html) di Panduan Pengembang Amazon SageMaker AI.
`CREATE MODEL`Operasi Amazon Redshift MLdengan `AUTO OFF` opsi yang saat ini mendukung XGBoost sebagai. `MODEL_TYPE` Anda dapat memberikan informasi yang relevan seperti tujuan dan hiperparameter sebagai bagian dari `CREATE MODEL` perintah, berdasarkan kasus penggunaan Anda.
Dalam tutorial ini, Anda menggunakan [dataset otentikasi uang kertas](https://archive.ics.uci.edu/ml/datasets/banknote+authentication), yang merupakan masalah klasifikasi biner untuk memprediksi apakah uang kertas yang diberikan asli atau palsu.
## Contoh kasus penggunaan
Anda dapat memecahkan masalah klasifikasi biner lainnya menggunakan Amazon Redshift ML, seperti memprediksi apakah pasien sehat atau memiliki penyakit. Anda juga bisa memprediksi apakah email itu spam atau bukan spam.
**Tugas**
+ Prasyarat
+ Langkah 1: Muat data dari Amazon S3 ke Amazon Redshift
+ Langkah 2: Buat model pembelajaran mesin
+ Langkah 3: Lakukan prediksi dengan model
## Prasyarat
Untuk menyelesaikan tutorial ini, Anda harus menyelesaikan [pengaturan Administratif](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html) untuk Amazon Redshift Ml.
## Langkah 1: Muat data dari Amazon S3 ke Amazon Redshift
Gunakan [editor kueri Amazon Redshift v2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) untuk menjalankan kueri berikut.
Kueri berikut membuat dua tabel, memuat data dari Amazon S3, dan membagi data menjadi satu set pelatihan dan satu set pengujian. Anda akan menggunakan set pelatihan untuk melatih model Anda dan membuat fungsi prediksi. Kemudian, Anda akan menguji fungsi prediksi pada set pengujian.
```
--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;
```
## Langkah 2: Buat model pembelajaran mesin
Kueri berikut membuat XGBoost model di Amazon Redshift MLdari set pelatihan yang Anda buat pada langkah sebelumnya. Ganti `amzn-s3-demo-bucket` dengan milik Anda sendiri`S3_BUCKET`, yang akan menyimpan dataset input Anda dan artefak Redshift ML lainnya.
```
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');
```
### Tampilkan status pelatihan model (opsional)
Anda dapat menggunakan perintah SHOW MODEL untuk mengetahui kapan model Anda siap.
Gunakan kueri berikut untuk memantau kemajuan pelatihan model.
```
SHOW MODEL model_banknoteauthentication_xgboost_binary;
```
Jika modelnya`READY`, operasi SHOW MODEL juga menyediakan `train:error` metrik, seperti yang ditunjukkan pada contoh output berikut. `train:error`Metrik adalah ukuran akurasi model Anda yang mengukur hingga enam tempat desimal. Nilai 0 paling akurat dan nilai 1 paling tidak akurat.
```
+--------------------------+--------------------------------------------------+
| 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 |
+--------------------------+--------------------------------------------------+
```
## Langkah 3: Lakukan prediksi dengan model
### Periksa keakuratan model
Kueri prediksi berikut menggunakan fungsi prediksi yang dibuat pada langkah sebelumnya untuk memeriksa keakuratan model Anda. Jalankan kueri ini pada set pengujian untuk memastikan model tidak sesuai terlalu dekat dengan set pelatihan. Korespondensi dekat ini juga dikenal sebagai overfitting, dan overfitting dapat menyebabkan model membuat prediksi yang tidak dapat diandalkan.
```
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;
```
### Memprediksi jumlah uang kertas asli dan palsu
Kueri prediksi berikut mengembalikan jumlah uang kertas asli dan palsu yang diprediksi dalam set pengujian.
```
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;
```
### Temukan pengamatan rata-rata untuk uang kertas asli dan palsu
Kueri prediksi berikut mengembalikan nilai rata-rata setiap fitur untuk uang kertas yang diprediksi asli dan palsu dalam set pengujian.
```
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;
```
## Topik terkait
Untuk informasi selengkapnya tentang Amazon Redshift ML, lihat dokumentasi berikut:
+ [Biaya untuk menggunakan Amazon Redshift ML](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [OPERASI BUAT MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [Fungsi EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)
Untuk informasi selengkapnya tentang pembelajaran mesin, lihat dokumentasi berikut:
+ [Ikhtisar pembelajaran mesin](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [Pembelajaran mesin untuk pemula dan ahli](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [Apa Keadilan dan Penjelasan Model untuk Prediksi Machine Learning?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)
# Tutorial: Membangun model regresi
Dalam tutorial ini, Anda menggunakan Amazon Redshift MLuntuk membuat model regresi pembelajaran mesin dan menjalankan kueri prediksi pada model. Model regresi memungkinkan Anda memprediksi hasil numerik, seperti harga rumah, atau berapa banyak orang yang akan menggunakan layanan penyewaan sepeda kota. Anda menggunakan perintah CREATE MODEL di Amazon Redshift dengan data pelatihan Anda. Kemudian, Amazon Redshift ML mengkompilasi model, mengimpor model terlatih ke Redshift, dan menyiapkan fungsi prediksi SQL. Anda dapat menggunakan fungsi prediksi dalam kueri SQL di Amazon Redshift.
Dalam tutorial ini, Anda akan menggunakan Amazon Redshift MLuntuk membangun model regresi yang memprediksi jumlah orang yang menggunakan layanan berbagi sepeda kota Toronto pada jam tertentu dalam sehari. Input untuk model termasuk hari libur dan kondisi cuaca. Anda akan menggunakan model regresi, karena Anda menginginkan hasil numerik untuk masalah ini.
Anda dapat menggunakan perintah CREATE MODEL untuk mengekspor data pelatihan, melatih model, dan membuat model tersedia di Amazon Redshift sebagai fungsi SQL. Gunakan operasi CREATE MODEL untuk menentukan data pelatihan baik sebagai tabel atau pernyataan SELECT.
## Contoh kasus penggunaan
Anda dapat memecahkan masalah regresi lainnya dengan Amazon Redshift ML, seperti memprediksi nilai seumur hidup pelanggan. Anda juga dapat menggunakan Redshift ML untuk memprediksi harga yang paling menguntungkan dan pendapatan yang dihasilkan dari suatu produk.
**Tugas**
+ Prasyarat
+ Langkah 1: Muat data dari Amazon S3 ke Amazon Redshift
+ Langkah 2: Buat model pembelajaran mesin
+ Langkah 3: Validasi model
## Prasyarat
Untuk menyelesaikan tutorial ini, Anda harus menyelesaikan [pengaturan Administratif](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html) untuk Amazon Redshift Ml.
## Langkah 1: Muat data dari Amazon S3 ke Amazon Redshift
Gunakan [editor kueri Amazon Redshift v2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) untuk menjalankan kueri berikut.
1. Anda harus membuat tiga tabel untuk memuat tiga kumpulan data publik ke Amazon Redshift. [Kumpulan data tersebut adalah Data [Pengendara Sepeda Toronto, data](https://open.toronto.ca/dataset/bike-share-toronto-ridership-data/)[cuaca historis, dan data liburan historis](https://climate.weather.gc.ca/historical_data/search_historic_data_e.html).](https://github.com/uWaterloo/Datasets/blob/master/Holidays/holidays.csv) Jalankan kueri berikut di editor kueri Amazon Redshift untuk membuat tabel bernama`ridership`,`weather`, dan. `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. Kueri berikut memuat data sampel ke dalam tabel yang Anda buat pada langkah sebelumnya.
```
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. Kueri berikut melakukan transformasi pada `weather` kumpulan data `ridership` dan untuk menghilangkan bias atau anomali. Menghapus bias dan anomali menghasilkan peningkatan akurasi model. Query menyederhanakan tabel dengan membuat dua tampilan baru yang disebut `ridership_view` dan`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. Query berikut membuat tabel yang menggabungkan semua atribut input yang relevan dari `ridership_view` dan `weather_view` ke dalam `trip_data` tabel.
```
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);
```
### Lihat data sampel (opsional)
Kueri berikut menunjukkan entri dari tabel. Anda dapat menjalankan operasi ini untuk memastikan tabel dibuat dengan benar.
```
SELECT *
FROM trip_data
LIMIT 5;
```
Berikut ini adalah contoh output dari operasi sebelumnya.
```
+---------------------+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
| 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 |
+---------------------+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
```
### Tampilkan korelasi antara atribut (opsional)
Menentukan korelasi membantu Anda mengukur kekuatan asosiasi antar atribut. Tingkat asosiasi dapat membantu Anda menentukan apa yang mempengaruhi output target Anda. Dalam tutorial ini, target output adalah`trip_count`.
Query berikut membuat atau menggantikan `sp_correlation` prosedur. Anda menggunakan prosedur tersimpan yang dipanggil `sp_correlation` untuk menunjukkan korelasi antara atribut dan atribut lainnya dalam tabel di 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;
```
Kueri berikut menunjukkan korelasi antara kolom target,`trip_count`, dan atribut numerik lainnya dalam dataset kami.
```
call sp_correlation(
'public',
'trip_data',
'trip_count',
'tmp_corr_table'
);
SELECT
*
FROM
tmp_corr_table;
```
Contoh berikut menunjukkan output dari `sp_correlation` operasi sebelumnya.
```
+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
| 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 |
+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
```
## Langkah 2: Buat model pembelajaran mesin
1. Kueri berikut membagi data Anda menjadi satu set pelatihan dan set validasi dengan menunjuk 80% dari dataset untuk pelatihan dan 20% untuk validasi. Set pelatihan adalah input untuk model ML untuk mengidentifikasi algoritme terbaik untuk model tersebut. Setelah model dibuat, Anda menggunakan set validasi untuk memvalidasi akurasi model.
```
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. Kueri berikut membuat model regresi untuk memprediksi `trip_count` nilai untuk setiap tanggal dan waktu masukan. Dalam contoh berikut, ganti amzn-s3-demo-bucket dengan bucket S3 Anda sendiri.
```
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
);
```
## Langkah 3: Validasi model
1. Gunakan kueri berikut untuk menampilkan aspek model, dan temukan metrik kesalahan kuadrat rata-rata dalam output. Mean square error adalah metrik akurasi khas untuk masalah regresi.
```
show model predict_rental_count;
```
1. Jalankan kueri prediksi berikut terhadap data validasi untuk membandingkan jumlah perjalanan yang diprediksi dengan jumlah perjalanan yang sebenarnya.
```
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. Kueri berikut menghitung kesalahan kuadrat rata-rata dan kesalahan kuadrat rata-rata akar berdasarkan data validasi Anda. Anda menggunakan kesalahan kuadrat rata-rata dan kesalahan kuadrat rata-rata akar untuk mengukur jarak antara target numerik yang diprediksi dan jawaban numerik yang sebenarnya. Model yang baik memiliki skor rendah di kedua metrik. Query berikut mengembalikan nilai kedua metrik.
```
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. Kueri berikut menghitung persen kesalahan dalam jumlah perjalanan untuk setiap waktu perjalanan pada 2017-01-01. Kueri memesan waktu perjalanan dari waktu dengan kesalahan persen terendah ke waktu dengan kesalahan persen tertinggi.
```
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;
```
## Topik terkait
Untuk informasi selengkapnya tentang Amazon Redshift ML, lihat dokumentasi berikut:
+ [Biaya untuk menggunakan Amazon Redshift ML](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [OPERASI BUAT MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [Fungsi EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)
Untuk informasi selengkapnya tentang pembelajaran mesin, lihat dokumentasi berikut:
+ [Ikhtisar pembelajaran mesin](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [Pembelajaran mesin untuk pemula dan ahli](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [Apa Keadilan dan Penjelasan Model untuk Prediksi Machine Learning?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)
# Tutorial: Membangun model regresi dengan pelajar linier
Dalam tutorial ini, Anda membuat model pembelajar linier dengan data dari Amazon S3 dan menjalankan kueri prediksi dengan model menggunakan Amazon Redshift ML. Algoritma pembelajar linier SageMaker AI memecahkan masalah regresi atau klasifikasi multi-kelas. Untuk mempelajari lebih lanjut tentang masalah regresi dan klasifikasi multi-kelas, lihat [Jenis masalah untuk paradigma pembelajaran mesin](https://docs.aws.amazon.com/sagemaker/latest/dg/algorithms-choose.html#basic-machine-learning-paradigms) di Panduan Pengembang Amazon SageMaker AI. Dalam tutorial ini, Anda memecahkan masalah regresi. Algoritma pembelajar linier melatih banyak model secara paralel, dan secara otomatis menentukan model yang paling dioptimalkan. Anda menggunakan operasi CREATE MODEL di Amazon Redshift, yang membuat model pembelajar linier menggunakan SageMaker AI dan mengirimkan fungsi prediksi ke Amazon Redshift. Untuk informasi selengkapnya tentang algoritme pembelajar linier, lihat Algoritma [Linear Learner](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html) di Panduan Pengembang Amazon SageMaker AI.
Anda dapat menggunakan perintah CREATE MODEL untuk mengekspor data pelatihan, melatih model, mengimpor model, dan menyiapkan fungsi prediksi Amazon Redshift. Gunakan operasi CREATE MODEL untuk menentukan data pelatihan baik sebagai tabel atau pernyataan SELECT.
Model pembelajar linier mengoptimalkan tujuan berkelanjutan atau tujuan diskrit. Tujuan kontinu digunakan untuk regresi, sedangkan variabel diskrit digunakan untuk klasifikasi. Beberapa metode memberikan solusi hanya untuk tujuan berkelanjutan, seperti metode regresi. Algoritma pembelajar linier memberikan peningkatan kecepatan dibandingkan teknik optimasi hiperparameter naif, seperti teknik Naive Bayes. Teknik optimasi naif mengasumsikan bahwa setiap variabel input independen. Untuk menggunakan algoritme pembelajar linier, Anda harus menyediakan kolom yang mewakili dimensi input, dan baris yang mewakili pengamatan. Untuk informasi selengkapnya tentang algoritme pembelajar linier, lihat Algoritma [Linear Learner](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html) di Panduan Pengembang Amazon SageMaker AI.
Dalam tutorial ini, Anda membangun model pembelajar linier yang memprediksi usia abalon. Anda menggunakan perintah CREATE MODEL pada [dataset Abalone](http://archive.ics.uci.edu/ml/datasets/Abalone) untuk menentukan hubungan antara pengukuran fisik abalon. Kemudian, Anda menggunakan model untuk menentukan usia abalon.
## Contoh kasus penggunaan
Anda dapat memecahkan masalah regresi lainnya dengan pelajar linier dan Amazon Redshift MS, seperti memprediksi harga rumah. Anda juga dapat menggunakan Redshift ML untuk memprediksi jumlah orang yang akan menggunakan layanan penyewaan sepeda kota.
**Tugas**
+ Prasyarat
+ Langkah 1: Muat data dari Amazon S3 ke Amazon Redshift
+ Langkah 2: Buat model pembelajaran mesin
+ Langkah 3: Validasi model
## Prasyarat
Untuk menyelesaikan tutorial ini, Anda harus menyelesaikan [pengaturan Administratif](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html) untuk Amazon Redshift Ml.
## Langkah 1: Muat data dari Amazon S3 ke Amazon Redshift
Gunakan [editor kueri Amazon Redshift v2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) untuk menjalankan kueri berikut. Kueri ini memuat data sampel ke dalam Redshift dan membagi data menjadi satu set pelatihan dan set validasi.
1. Query berikut membuat `abalone_dataset` tabel.
```
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. Kueri berikut menyalin data sampel dari [kumpulan data Abalone](http://archive.ics.uci.edu/ml/datasets/Abalone) di Amazon S3 ke tabel yang Anda buat `abalone_dataset` sebelumnya di Amazon Redshift.
```
COPY abalone_dataset
FROM
's3://redshift-ml-multiclass/abalone.csv' REGION 'us-east-1' IAM_ROLE default CSV IGNOREHEADER 1 NULL AS 'NULL';
```
1. Dengan memisahkan data secara manual, Anda akan dapat memverifikasi keakuratan model dengan mengalokasikan set prediksi tambahan. Query berikut membagi data menjadi dua set. `abalone_training`Tabel untuk pelatihan dan `abalone_validation` tabel untuk validasi.
```
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;
```
## Langkah 2: Buat model pembelajaran mesin
Pada langkah ini, Anda menggunakan pernyataan CREATE MODEL untuk membuat model pembelajaran mesin Anda dengan algoritme pembelajar linier.
Kueri berikut membuat model pembelajar linier dengan operasi CREATE MODEL menggunakan bucket S3 Anda. Ganti amzn-s3-demo-bucket dengan bucket S3 Anda sendiri.
```
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
);
```
### Tampilkan status pelatihan model (opsional)
Anda dapat menggunakan perintah SHOW MODEL untuk mengetahui kapan model Anda siap.
Gunakan kueri berikut untuk memantau kemajuan pelatihan model.
```
SHOW MODEL model_abalone_ring_prediction;
```
Ketika model siap, output dari operasi sebelumnya akan terlihat mirip dengan contoh berikut. Perhatikan bahwa output menyediakan `validation:mse` metrik, yang merupakan kesalahan kuadrat rata-rata. Anda akan menggunakan kesalahan kuadrat rata-rata untuk memvalidasi keakuratan model pada langkah berikutnya.
```
+--------------------------+----------------------------------------------------------------------------------------------------+
| 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 |
+--------------------------+----------------------------------------------------------------------------------------------------+
```
## Langkah 3: Validasi model
1. Kueri prediksi berikut memvalidasi keakuratan model pada `abalone_validation` kumpulan data dengan menghitung kesalahan kuadrat rata-rata dan kesalahan kuadrat rata-rata akar.
```
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;
```
Output dari query sebelumnya akan terlihat seperti contoh berikut. Nilai metrik kesalahan kuadrat rata-rata harus serupa dengan `validation:mse` metrik yang ditunjukkan oleh output operasi SHOW MODEL.
```
+-----+--------------------+
| mse | rmse |
+-----+--------------------+
| 5.1 | 2.2600000000000002 |
+-----+--------------------+
```
1. Gunakan kueri berikut untuk menjalankan operasi EXPLAIN\$1MODEL pada fungsi prediksi Anda. Operasi akan mengembalikan laporan penjelasan model. Untuk informasi selengkapnya tentang operasi EXPLAIN\$1MODEL, lihat fungsi [EXPLAIN\$1MODEL di](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html) Panduan Pengembang Database Amazon Redshift.
```
SELECT
EXPLAIN_MODEL ('model_abalone_ring_prediction');
```
Informasi berikut adalah contoh laporan penjelasan model yang dihasilkan oleh operasi EXPLAIN\$1MODEL sebelumnya. Nilai untuk masing-masing input adalah nilai Shapley. Nilai Shapley mewakili efek setiap input terhadap prediksi model Anda, dengan input bernilai lebih tinggi memiliki dampak lebih besar pada prediksi. Dalam contoh ini, input bernilai lebih tinggi memiliki dampak lebih besar pada prediksi usia abalon.
```
{
"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. Gunakan kueri berikut untuk menghitung persentase prediksi yang benar yang dibuat model tentang abalon yang belum matang. Abalone yang belum matang memiliki 10 cincin atau kurang, dan prediksi yang benar akurat dalam satu cincin dari jumlah cincin yang sebenarnya.
```
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;
```
## Topik terkait
Untuk informasi selengkapnya tentang Amazon Redshift ML, lihat dokumentasi berikut:
+ [Biaya untuk menggunakan Amazon Redshift ML](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [OPERASI BUAT MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [Fungsi EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)
Untuk informasi selengkapnya tentang pembelajaran mesin, lihat dokumentasi berikut:
+ [Ikhtisar pembelajaran mesin](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [Pembelajaran mesin untuk pemula dan ahli](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [Apa Keadilan dan Penjelasan Model untuk Prediksi Machine Learning?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)
# Tutorial: Membangun model klasifikasi multi-kelas dengan pelajar linier
Dalam tutorial ini, Anda membuat model pembelajar linier dengan data dari Amazon S3, lalu menjalankan kueri prediksi dengan model menggunakan Amazon Redshift ML. Algoritma pembelajar linier SageMaker AI memecahkan masalah regresi atau klasifikasi. Untuk mempelajari lebih lanjut tentang masalah regresi dan klasifikasi multi-kelas, lihat [Jenis masalah untuk paradigma pembelajaran mesin](https://docs.aws.amazon.com/sagemaker/latest/dg/algorithms-choose.html#basic-machine-learning-paradigms) di Panduan Pengembang Amazon SageMaker AI. Dalam tutorial ini, Anda memecahkan masalah klasifikasi multi-kelas. Algoritma pembelajar linier melatih banyak model secara paralel, dan secara otomatis menentukan model yang paling dioptimalkan. Anda menggunakan operasi CREATE MODEL di Amazon Redshift, yang membuat model pembelajar linier menggunakan SageMaker AI dan mengirimkan fungsi prediksi ke Amazon Redshift. Untuk informasi selengkapnya tentang algoritme pembelajar linier, lihat Algoritma [Linear Learner](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html) di Panduan Pengembang Amazon SageMaker AI.
Anda dapat menggunakan perintah CREATE MODEL untuk mengekspor data pelatihan, melatih model, mengimpor model, dan menyiapkan fungsi prediksi Amazon Redshift. Gunakan operasi CREATE MODEL untuk menentukan data pelatihan baik sebagai tabel atau pernyataan SELECT.
Model pembelajar linier mengoptimalkan tujuan berkelanjutan atau tujuan diskrit. Tujuan kontinu digunakan untuk regresi, sedangkan variabel diskrit digunakan untuk klasifikasi. Beberapa metode memberikan solusi hanya untuk tujuan berkelanjutan, seperti metode regresi. Algoritma pembelajar linier memberikan peningkatan kecepatan dibandingkan teknik optimasi hiperparameter naif, seperti teknik Naive Bayes. Teknik optimasi naif mengasumsikan bahwa setiap variabel input independen. Algoritma pembelajar linier melatih banyak model secara paralel dan memilih model yang paling dioptimalkan. Algoritma serupa adalah XGBoost, yang menggabungkan perkiraan dari serangkaian model yang lebih sederhana dan lebih lemah untuk membuat prediksi. Untuk mempelajari selengkapnya XGBoost, lihat [XGBoost algoritme](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html) di Panduan Pengembang Amazon SageMaker AI.
Untuk menggunakan algoritme pembelajar linier, Anda harus menyediakan kolom yang mewakili dimensi input, dan baris yang mewakili pengamatan. Untuk informasi selengkapnya tentang algoritme pembelajar linier, lihat Algoritma [Linear Learner](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html) di Panduan Pengembang Amazon SageMaker AI.
Dalam tutorial ini, Anda membangun model pembelajar linier yang memprediksi jenis penutup untuk area tertentu. Anda menggunakan perintah CREATE MODEL pada [dataset Covertype](https://archive.ics.uci.edu/ml/datasets/covertype) dari UCI Machine Learning Repository. Kemudian, Anda menggunakan fungsi prediksi yang dibuat oleh perintah untuk menentukan jenis penutup di area hutan belantara. Jenis tutupan hutan biasanya merupakan jenis pohon. Input yang akan digunakan Redshift MLuntuk membuat model termasuk jenis tanah, jarak ke jalan raya, dan penunjukan area hutan belantara. Untuk informasi selengkapnya tentang kumpulan data, lihat Dataset [Jenis Covertype dari UCI](https://archive.ics.uci.edu/ml/datasets/covertype) Machine Learning Repository.
## Contoh kasus penggunaan
Anda dapat memecahkan masalah klasifikasi multi-kelas lainnya dengan pembelajar linier dengan Amazon Redshift ML. seperti memprediksi spesies tanaman dari gambar. Anda juga dapat memprediksi jumlah produk yang akan dibeli pelanggan.
**Tugas**
+ Prasyarat
+ Langkah 1: Muat data dari Amazon S3 ke Amazon Redshift
+ Langkah 2: Buat model pembelajaran mesin
+ Langkah 3: Validasi model
## Prasyarat
Untuk menyelesaikan tutorial ini, Anda harus menyelesaikan [pengaturan Administratif](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html) untuk Amazon Redshift Ml.
## Langkah 1: Muat data dari Amazon S3 ke Amazon Redshift
Gunakan [editor kueri Amazon Redshift v2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) untuk menjalankan kueri berikut. Kueri ini memuat data sampel ke dalam Redshift dan membagi data menjadi satu set pelatihan dan set validasi.
1. Query berikut membuat `covertype_data` tabel.
```
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. Kueri berikut menyalin data sampel dari [kumpulan data Covertype](https://archive.ics.uci.edu/ml/datasets/covertype) di Amazon S3 ke tabel yang Anda buat `covertype_data` sebelumnya di Amazon Redshift.
```
COPY public.covertype_data
FROM
's3://redshift-ml-multiclass/covtype.data.gz' IAM_ROLE DEFAULT gzip DELIMITER ',' REGION 'us-east-1';
```
1. Dengan memisahkan data secara manual, Anda akan dapat memverifikasi keakuratan model dengan mengalokasikan set pengujian tambahan. Query berikut membagi data menjadi tiga set. `covertype_training`Tabel untuk pelatihan, `covertype_validation` tabel untuk validasi, dan `covertype_test` tabel untuk menguji model Anda. Anda akan menggunakan set pelatihan untuk melatih model Anda dan set validasi untuk memvalidasi pengembangan model. Kemudian, Anda menggunakan set pengujian untuk menguji kinerja model dan melihat apakah model tersebut terlalu pas atau tidak sesuai dengan kumpulan data.
```
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;
```
## Langkah 2: Buat model pembelajaran mesin
Pada langkah ini, Anda menggunakan pernyataan CREATE MODEL untuk membuat model pembelajaran mesin Anda dengan algoritme pembelajar linier.
Kueri berikut membuat model pembelajar linier dengan operasi CREATE MODEL menggunakan bucket S3 Anda. Ganti amzn-s3-demo-bucket dengan bucket S3 Anda sendiri.
```
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
);
```
### Tampilkan status pelatihan model (opsional)
Anda dapat menggunakan perintah SHOW MODEL untuk mengetahui kapan model Anda siap.
Gunakan kueri berikut untuk memantau kemajuan pelatihan model.
```
SHOW MODEL forest_cover_type_model;
```
Ketika model siap, output dari operasi sebelumnya akan terlihat mirip dengan contoh berikut. Perhatikan bahwa output menyediakan `validation:multiclass_accuracy` metrik, yang dapat Anda lihat di sisi kanan contoh berikut. Akurasi multi-kelas mengukur persentase titik data yang diklasifikasikan dengan benar oleh model. Anda akan menggunakan akurasi multi-kelas untuk memvalidasi keakuratan model pada langkah berikutnya.
```
+--------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| 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 |
+--------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
```
## Langkah 3: Validasi model
1. Kueri prediksi berikut memvalidasi keakuratan model pada `covertype_validation` kumpulan data dengan menghitung akurasi multi-kelas. Akurasi multi-kelas adalah persentase prediksi model yang benar.
```
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;
```
Output dari query sebelumnya akan terlihat seperti contoh berikut. Nilai metrik akurasi multi-kelas harus serupa dengan `validation:multiclass_accuracy` metrik yang ditunjukkan oleh output operasi SHOW MODEL.
```
+-------------------+-----------------------+-------------------+--------------+
| predicted_matches | predicted_non_matches | total_predictions | pct_accuracy |
+-------------------+-----------------------+-------------------+--------------+
| 41211 | 16324 | 57535 | 0.71627704 |
+-------------------+-----------------------+-------------------+--------------+
```
1. Kueri berikut memprediksi jenis sampul yang paling umum untuk`wilderness_area2`. Dataset ini mencakup empat area hutan belantara dan tujuh jenis penutup. Area hutan belantara dapat memiliki beberapa jenis penutup.
```
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;
```
Output dari operasi sebelumnya akan terlihat mirip dengan contoh berikut. Output ini berarti bahwa model memprediksi bahwa mayoritas penutup adalah tipe penutup 1, dan ada beberapa penutup jenis penutup 2 dan 7.
```
+----------------------+-------+
| predicted_cover_type | count |
+----------------------+-------+
| 2 | 564 |
| 7 | 97 |
| 1 | 2309 |
+----------------------+-------+
```
1. Kueri berikut menunjukkan jenis penutup yang paling umum di satu area hutan belantara. Kueri menampilkan jumlah jenis penutup itu dan area hutan belantara tipe penutup.
```
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;
```
Output dari operasi sebelumnya akan terlihat mirip dengan contoh berikut.
```
+----------------------+-------+-----------------+
| predicted_cover_type | count | wilderness_area |
+----------------------+-------+-----------------+
| 2 | 15738 | 1 |
+----------------------+-------+-----------------+
```
## Topik terkait
Untuk informasi selengkapnya tentang Amazon Redshift ML, lihat dokumentasi berikut:
+ [Biaya untuk menggunakan Amazon Redshift ML](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [OPERASI BUAT MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [Fungsi EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)
Untuk informasi selengkapnya tentang pembelajaran mesin, lihat dokumentasi berikut:
+ [Ikhtisar pembelajaran mesin](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [Pembelajaran mesin untuk pemula dan ahli](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [Apa Keadilan dan Penjelasan Model untuk Prediksi Machine Learning?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)