Panduan Lengkap Machine Learning di AWS dengan Amazon SageMaker

Meskipun kebanyakan orang mengaitkan Amazon dengan pengiriman Prime dan konten, perusahaan ini juga sangat digemari di kalangan pengembang. Secara khusus, Amazon Web Services (AWS) menawarkan teknologi cloud untuk lebih dari 1 juta pengguna aktif, termasuk korporasi tingkat enterprise serta bisnis kecil dan menengah.

Pada artikel ini, kita akan berfokus pada AWS SageMaker, platform khusus untuk menjalankan alur kerja machine learning (ML) end-to-end dalam skala besar yang merupakan bagian dari ekosistem AWS. Di akhir artikel, kita akan memiliki model yang diterapkan (deployed) dan dapat digunakan untuk mengirim permintaan guna menghasilkan prediksi untuk tugas klasifikasi.

Apa itu Amazon SageMaker?

Amazon SageMaker adalah layanan terkelola penuh yang menyediakan alat dan infrastruktur untuk membangun, melatih, dan menerapkan model machine learning. Layanan ini menyederhanakan alur kerja machine learning, sehingga data scientist dan pengembang dapat membuat, melatih, dan menerapkan model dengan cepat dan efisien.

Dalam proyek machine learning yang umum, Anda akan melalui banyak tahap:

• Ingesti, pembersihan, dan eksplorasi data.
• Rekayasa dan seleksi fitur.
• Pelatihan model dan penalaan hiperparameter.
• Penerapan (deploy) dan pemantauan model.

Setiap tahap memerlukan seperangkat alat yang berbeda dan tim ahli yang terampil untuk mengorkestrasikannya secara mulus. Amazon SageMaker menghadirkan keseluruhan proses ini ke dalam satu platform. Berikut beberapa keuntungannya:

• Layanan machine learning end-to-end: Menyediakan rangkaian alat lengkap untuk setiap tahap siklus hidup machine learning, mulai dari persiapan data hingga penerapan dan pemantauan model.
• Lingkungan pengembangan terintegrasi: SageMaker Studio menawarkan IDE yang menyederhanakan seluruh alur kerja ML, memungkinkan pengguna membangun, melatih, dan menerapkan model dari satu antarmuka.
• Mudah digunakan: Fitur seperti SageMaker Autopilot memungkinkan pengguna tanpa pengalaman pemrograman menghasilkan model berkualitas tinggi hanya dengan beberapa klik.
• Skalabilitas: Secara otomatis melakukan penskalaan infrastruktur untuk pelatihan dan penerapan model, memastikan kinerja optimal tanpa intervensi manual.
• Hemat biaya: Menawarkan opsi seperti Spot Training dan endpoint multi-model untuk menurunkan biaya pelatihan dan hosting.
• Dukungan untuk framework ML populer: Memungkinkan data scientist menggunakan framework pilihan mereka, termasuk TensorFlow, PyTorch, dan XGBoost.
• Penalaan hiperparameter otomatis: Menemukan konfigurasi model dengan kinerja terbaik dengan menyetel hiperparameter secara otomatis.
• Penerapan model yang andal: Menyederhanakan penerapan model sebagai API real-time atau layanan prediksi batch, sehingga mudah diintegrasikan ke dalam aplikasi.
• Pemantauan komprehensif: SageMaker Model Monitor secara kontinu melacak kinerja model, mendeteksi data drift dan anomali di produksi.
• Registri model: Mengelola siklus hidup model machine learning, termasuk versi, alur persetujuan, dan riwayat penerapan.
• Integrasi tanpa hambatan: Mudah terintegrasi dengan layanan AWS lainnya, seperti Amazon S3 untuk penyimpanan data, AWS Glue untuk persiapan data, AWS Lambda untuk pemrosesan berbasis peristiwa, dan Amazon CloudWatch untuk pemantauan dan pencatatan log.
• Keamanan dan kepatuhan: Menjamin perlindungan data dan kepatuhan terhadap standar industri melalui fitur keamanan yang tangguh, termasuk dukungan VPC, enkripsi, dan kebijakan IAM.

Manfaat-manfaat ini menjadikan Amazon SageMaker sebagai platform yang kuat dan fleksibel untuk membangun, melatih, dan menerapkan model machine learning dalam skala besar.

Menyiapkan Konsol AWS dan Lingkungan untuk SageMaker

Seperti disebutkan, SageMaker adalah bagian dari ekosistem AWS, yang mencakup banyak solusi komputasi cloud yang menyediakan penyimpanan, jaringan, basis data, analitik, dan kapabilitas machine learning. Semua solusi ini bekerja selaras dengan SageMaker untuk menyatukan alur kerja machine learning Anda.

Karena itu, SageMaker mengharuskan Anda membuat akun AWS jika Anda belum memilikinya.

1. Membuat akun AWS

Untuk membuat akun, buka https://aws.amazon.com/ dan ikuti proses untuk membuat akun baru.

Proses pendaftaran mencakup penambahan informasi penagihan dan verifikasi nomor telepon. Jangan khawatir — Anda tidak akan ditagih sampai Anda benar-benar mulai menggunakan beberapa fungsionalitas SageMaker (yang biasanya hemat biaya).

Setelah selesai, Anda akan diarahkan ke konsol AWS Anda, yang umumnya tampak seperti gambar berikut. Perlu diingat, beberapa widget konsol mungkin berbeda pada kasus Anda.

2. Membuat instance notebook

Sekarang, kita akan membuat sesi JupyterLab untuk mengeksekusi kode pada mesin cloud milik Amazon.

Dari konsol AWS Anda, cari dasbor SageMaker menggunakan bilah pencarian di bagian atas layar:

Kemudian, gulir ke bawah untuk menemukan tab “Notebooks”, dan di dalamnya, opsi “Notebooks instances”. Anda belum melihat instance apa pun, jadi kita perlu membuat satu:

Untuk membuat notebook baru, klik “Create notebook instance” di pojok kanan atas layar. Lalu isi kolom-kolom berikut:

• Berikan nama untuk notebook Anda. Dalam contoh ini, saya menamai sagemaker-test.
• Kolom “Notebook instance type” menentukan jenis mesin yang Anda inginkan untuk kernel notebook Anda. Saya memilih ml.t3.large, yang memiliki RAM 8 GB dan 2 inti CPU. Saat penulisan, biayanya sekitar $0,12 per jam (lihat halaman harga SageMaker untuk informasi terbaru).
• Pada bagian “Permissions and encryption”, pilih opsi “Create new user”, yang akan otomatis membuat pengguna IAM dengan izin yang diperlukan untuk menjalankan instance notebook Anda.

Setelah Anda mengisi semua informasi yang diperlukan, klik “Create notebook instance”.

Ketika status “Pending” berubah menjadi “inService”, Anda dapat meluncurkan JupyterLab dengan mengeklik tautan “Open in JupyterLab” di sebelah notebook:

Begitu instance aktif, waktu mulai berjalan dan penagihan dimulai. Jika Anda memutuskan untuk beristirahat, jangan lupa menghentikan instance dengan mengeklik “Actions” lalu “Stop” untuk mencegah biaya yang tidak perlu. Waktu henti otomatis adalah dua jam secara default:

Jika Anda menghentikan instance notebook, Anda dapat menyalakannya kembali nanti. Lingkungan Anda akan tetap dipertahankan.

Mengunggah Dataset untuk Digunakan di AWS SageMaker

Di bagian ini, kita akan mempelajari cara mengunggah file lokal ke server Amazon, yang merupakan persyaratan untuk SageMaker.

1. Mengunduh dataset contoh

Kita akan membangun pengklasifikasi multi-kelas menggunakan Dry Bean dataset dari repositori UCI ML. Dataset ini berisi 13 ribu instance kacang dan 15 pengukuran numeriknya.

Tugasnya adalah mengklasifikasikannya ke dalam tujuh jenis kacang: Seker, Barbunya, Bombay, Cali, Dermosan, Horoz, dan Sira.

Tujuh jenis kacang: Seker, Barbunya, Bombay, Cali, Dermosan, Horoz, dan Sira.

Setelah mengunduh, simpan file Excel di dalam ZIP yang diunduh ke direktori data lokal Anda di JupyterLab, lalu tambahkan kode berikut ke notebook Anda:

from pathlib import Path

cwd = Path.cwd()
data_path = cwd / "data" / "Dry_Bean_Dataset.xlsx"

Kemudian, dengan menambahkan kode berikut, kita dapat membaca file Excel dengan pandas dan menyimpannya sebagai CSV:

import pandas as pd

beans = pd.read_excel(data_path)
beans.to_csv(cwd / "data" / "dry_bean.csv", index=False)

2. Membuat bucket S3 dan mengunggah data ke dalamnya

Dataset kita harus berada di dalam bucket S3 agar SageMaker dapat mengaksesnya. AWS S3 adalah solusi penyimpanan cloud yang memungkinkan Anda menyimpan objek terkait proyek di dalam bucket yang dihosting di server Amazon.

Untuk membuat bucket, ikuti langkah-langkah berikut:

• Buka konsol S3. Anda dapat mencari “S3” di bilah pencarian.
• Klik “Create bucket”.
• Beri nama bucket Anda.
• Nama bucket harus unik secara global, jadi Anda tidak akan bisa menggunakan dry-bean-bucket seperti yang saya lakukan.
• Biarkan konfigurasi default pada kolom lainnya.
• Klik “Create bucket”.

Setelah bucket dibuat, klik bucket tersebut untuk mengunggah file CSV yang telah kita simpan sebelumnya:

• Di dalam bucket, klik “Upload” lalu “Add files”.
• Pilih file CSV.
• Klik “Upload” lagi.

Setelah itu, Anda dapat kembali ke antarmuka JupyterLab karena kita akhirnya akan menjalankan beberapa kode!

Alur Kerja Pelatihan dan Penerapan Model End-to-end di AWS SageMaker

Di bagian ini, kita akan melalui alur kerja end-to-end yang akan membawa kita dari dataset CSV hingga model yang diterapkan ke sebuah endpoint. Namun sebelum masuk ke detail teknis, mari sejenak memahami gambaran tingkat tingginya.

Gambaran tingkat tinggi alur kerja ML di SageMaker

Mengerjakan machine learning di SageMaker sedikit berbeda dibandingkan di mesin lokal Anda. Kita sudah membahas langkah-langkah pertama:

• Membuat akun AWS.
• Membuat instance notebook.
• Membuat bucket S3 untuk proyek.

Sama seperti notebook lokal Anda, instance notebook SageMaker diperuntukkan analisis eksploratif — pembersihan data, eksplorasi, ingest, dan eksperimen dasar.

Setelah Anda memasuki fase pelatihan model, SageMaker mengharapkan Anda mengikuti aturannya. Secara khusus, agar SageMaker dapat menerapkan model kustom Anda sebagai endpoint, SageMaker memerlukan skrip pelatihan yang melakukan hal-hal berikut:

• Memuat data dari sumbernya.
• Melatih satu model di atasnya.
• Menyimpan model dan artefaknya.
• Melaporkan metriknya.

Skrip tersebut juga harus secara dinamis menerima variabel apa pun sebagai argumen baris perintah. Jadi, apa pun yang ingin Anda ubah di masa depan di dalam skrip harus diatur sebagai argumen baris perintah (hiperparameter model, path file, dan sebagainya).

Setelah skrip ini siap, skrip akan diberikan ke estimator khusus yang disediakan oleh SageMaker. Estimator ini mendampingi pustaka ML populer seperti scikit-learn, XGBoost, TensorFlow, PyTorch, dan sebagainya. Dengan estimator ini, SageMaker membangun kontainer Docker di sekitar skrip Anda, lalu menerapkannya sebagai endpoint agar dapat dilayani dalam skala besar.

Semua poin sebelumnya akan semakin masuk akal saat kita melaluinya langkah demi langkah.

1. Menyiapkan instance notebook untuk SageMaker

Mari mulai dengan mengimpor pustaka yang diperlukan di dalam notebook sagemaker-test yang Anda buat sebelumnya:

import boto3
import numpy as np
import pandas as pd
import sagemaker
from sagemaker import get_execution_role
from sklearn.model_selection import train_test_split

Berikut fungsi beberapa impor tersebut:

• sagemaker adalah SDK Python resmi yang melatih dan menerapkan model machine learning di Amazon SageMaker. Dengan SDK ini, Anda dapat melatih dan menerapkan model menggunakan framework deep learning populer, algoritme yang disediakan Amazon, atau algoritme Anda sendiri yang dibangun ke dalam image Docker yang kompatibel dengan SageMaker.
• boto3 adalah SDK Python resmi lainnya, tetapi berfungsi sebagai jembatan antara kode Anda dan semua layanan AWS, bukan hanya SageMaker. Anda dapat mempelajari lebih lanjut tentang boto3 di kursus ini.

Setelah impor, mari buat beberapa resource yang akan kita perlukan sepanjang tutorial:

sm_boto3 = boto3.client("sagemaker")
sess = sagemaker.Session()

• Pada kode di atas, pertama-tama kita membuat objek klien SageMaker menggunakan boto3.
• Lalu, kita membuat sesi SageMaker.

Kedua objek ini memungkinkan kita berinteraksi dengan platform SageMaker dengan cara yang berbeda.

Sekarang, mari kita definisikan beberapa variabel global yang diperlukan:

region = sess.boto_session.region_name
BUCKET_URI = "s3://dry-bean-bucket"
BUCKET_NAME = "dry-bean-bucket"
DATASET_PATH = f"{BUCKET_URI}/dry_bean.csv"
TARGET_NAME = "Class"

Variabel-variabel ini cukup jelas dan akan kita gunakan sepanjang tutorial.

2. Memuat data dari bucket S3 ke dalam SageMaker

Dalam kebanyakan proyek data Anda, dataset pelatihan akan disimpan di solusi penyimpanan cloud seperti BigQuery, GCS, atau bucket AWS S3. Kita menyimpannya di opsi terakhir, jadi mari muat menggunakan pandas. Untuk melakukannya, tambahkan kode berikut ke notebook Anda dan jalankan:

dry_bean = pd.read_csv(DATASET_PATH)
dry_bean.head()

Salah satu keuntungan bekerja di notebook Sagemaker adalah kita dapat membaca file dari S3 menggunakan pandas secara langsung. Semua lingkungan SageMaker dikonfigurasi dengan kredensial Anda agar pandas dapat mengunduh CSV dari bucket. Kode ini tidak akan berhasil jika Anda menjalankannya secara lokal.

3. Melakukan EDA di SageMaker

Melakukan sedikit EDA (Exploratory Data Analysis) harus menjadi bagian dari setiap proyek yang Anda kerjakan dan proyek ini bukan pengecualian. Namun, kita tidak akan melakukan analisis mendalam di sini karena akan mengalihkan fokus dari topik utama artikel.

Kita akan cukup mencetak beberapa statistik ringkas dan bagan:

dry_bean.info()

<class 'pandas.core.frame.DataFrame'>

RangeIndex: 13611 entries, 0 to 13610

Data columns (total 17 columns):

#   Column           Non-Null Count  Dtype 

---  ------           --------------  ----- 

0   Area             13611 non-null  int64 

1   Perimeter        13611 non-null  float64

2   MajorAxisLength  13611 non-null  float64

3   MinorAxisLength  13611 non-null  float64

4   AspectRation     13611 non-null  float64

5   Eccentricity     13611 non-null  float64

6   ConvexArea       13611 non-null  int64 

7   EquivDiameter    13611 non-null  float64

8   Extent           13611 non-null  float64

9   Solidity         13611 non-null  float64

10  roundness        13611 non-null  float64

11  Compactness      13611 non-null  float64

12  ShapeFactor1     13611 non-null  float64

13  ShapeFactor2     13611 non-null  float64

14  ShapeFactor3     13611 non-null  float64

15  ShapeFactor4     13611 non-null  float64

16  Class            13611 non-null  object

dtypes: float64(14), int64(2), object(1)

memory usage: 1.8+ MB

Informasi di atas memberi tahu kita bahwa terdapat 16 fitur numerik dan satu target bernama Class. Dataset ini kecil, hanya 13 ribu instance, jadi kita tidak memerlukan mesin bertenaga besar atau menghabiskan banyak biaya untuk melatih model.

Selanjutnya, mari buat pair plot dari beberapa fitur penting menggunakan seaborn:

import seaborn as sns

sns.pairplot(
   dry_bean,
   vars=["Area", "MajorAxisLength", "MinorAxisLength", "Eccentricity", "roundness"],
   hue="Class",
);

Plot di atas menunjukkan bahwa kacang-kacang tersebut jelas berbeda dalam hal pengukuran fisiknya. Kacang hijau (Bombay) terlihat sangat terdefinisi.

Kita juga dapat memplot matriks korelasi untuk melihat hubungan antarf fitur:

import matplotlib.pyplot as plt

correlation = dry_bean.corr(numeric_only=True)

# Create a square heatmap with center at 0
sns.heatmap(correlation, center=0, square=True, cmap="coolwarm", vmin=-1, vmax=1)
plt.show()

Plot menunjukkan banyak fitur yang berkorelasi sempurna (positif dan negatif), yang masuk akal karena semua fitur terkait dengan pengukuran fisik.

Sampai titik ini, saya serahkan kepada Anda untuk melanjutkan eksplorasi.

4. Menyiapkan data untuk pelatihan model di SageMaker

Setelah eksplorasi, Anda harus mengatasi masalah kualitas atau logika dalam dataset dan merekayasa fitur baru jika diperlukan sebelum pelatihan.

Dataset Dry Bean cukup bersih, jadi pekerjaan kita mudah. Kita hanya perlu mengenkode target karena berisi teks. Kita akan menggunakan scikit-learn untuk melakukan ini:

from sklearn.preprocessing import LabelEncoder

# For preprocessing
df = dry_bean.copy(deep=True)

# Encode the target
le = LabelEncoder()
df[TARGET_NAME] = le.fit_transform(df[TARGET_NAME])

Setelah prapemrosesan selesai, kita harus membagi dataset:

from sklearn.model_selection import train_test_split

# Split the data into two sets
train, test = train_test_split(df, random_state=1, test_size=0.2)

Anda dapat membagi data lebih lanjut menjadi set validasi ketiga jika diinginkan, namun untuk saat ini kita akan tetap sederhana.

Sekarang, mari simpan dataset sebagai CSV:

train.to_csv("dry-bean-train.csv")
test.to_csv("dry-bean-test.csv")

Dan unggah ke bucket S3 kita:

# Send data to S3. SageMaker will take training data from s3
trainpath = sess.upload_data(
   path="dry-bean-train.csv",
   bucket=BUCKET_NAME,
   key_prefix="sagemaker/sklearncontainer",
)

testpath = sess.upload_data(
   path="dry-bean-test.csv",
   bucket=BUCKET_NAME,
   key_prefix="sagemaker/sklearncontainer",
)

Fungsi .upload_data() dari objek sesi mengembalikan path penuh ke file yang diunggah, yang disimpan dalam variabel trainpath dan testpath. Kita akan menggunakan path ini nanti.

5. Menulis skrip pelatihan untuk SageMaker

Di sel notebook baru, tempelkan kode berikut:

%%writefile script.py

import argparse
import os
import joblib
import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import balanced_accuracy_score

if __name__ == "__main__":
   print("extracting arguments")
   parser = argparse.ArgumentParser()

   # Hyperparameters sent by the client are passed as command-line arguments to the script.
   parser.add_argument("--n-estimators", type=int, default=10)
   parser.add_argument("--min-samples-leaf", type=int, default=3)

   # Data, model, and output directories
   parser.add_argument("--model-dir", type=str, default=os.environ.get("SM_MODEL_DIR"))
   parser.add_argument("--train", type=str, default=os.environ.get("SM_CHANNEL_TRAIN"))
   parser.add_argument("--test", type=str, default=os.environ.get("SM_CHANNEL_TEST"))
   parser.add_argument("--train-file", type=str, default="dry-bean-train.csv")
   parser.add_argument("--test-file", type=str, default="dry-bean-test.csv")
   args, _ = parser.parse_known_args()
   
   print("reading data")

   train_df = pd.read_csv(os.path.join(args.train, args.train_file))
   test_df = pd.read_csv(os.path.join(args.test, args.test_file))

   print("building training and testing datasets")

   X_train = train_df.drop("Class", axis=1)
   X_test = test_df.drop("Class", axis=1)
   y_train = train_df[["Class"]]
   y_test = test_df[["Class"]]

   # Train model
   print("training model")

   model = RandomForestClassifier(
       n_estimators=args.n_estimators,
       min_samples_leaf=args.min_samples_leaf,
       n_jobs=-1,
   )

   model.fit(X_train, y_train)

   # Print abs error
   print("validating model")

   bal_acc_train = balanced_accuracy_score(y_train, model.predict(X_train))
   bal_acc_test = balanced_accuracy_score(y_test, model.predict(X_test))

   print(f"Train balanced accuracy: {bal_acc_train:.3f}")
   print(f"Test balanced accuracy: {bal_acc_test:.3f}")

   # Persist model
   path = os.path.join(args.model_dir, "model.joblib")
   joblib.dump(model, path)
   print("model persisted at " + path)

Perintah magic %%writefile script.py pada skrip di atas mengubah isi sel menjadi skrip Python alih-alih menjalankannya.

Sekarang, mari kita telusuri apa yang terjadi di skrip tersebut langkah demi langkah:

import argparse
import os
import joblib
import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import balanced_accuracy_score

Pertama, kita mengimpor beberapa pustaka yang diperlukan.

if __name__ == "__main__":
   print("extracting arguments")
   parser = argparse.ArgumentParser()
   
   # Hyperparameters sent by the client are passed as command-line arguments to the script.
   parser.add_argument("--n-estimators", type=int, default=10)
   parser.add_argument("--min-samples-leaf", type=int, default=3)

   # Data, model, and output directories
   parser.add_argument("--model-dir", type=str, default=os.environ.get("SM_MODEL_DIR"))
   parser.add_argument("--train", type=str, default.os.environ.get("SM_CHANNEL_TRAIN"))
   parser.add_argument("--test", type=str, default=os.environ.get("SM_CHANNEL_TEST"))
   parser.add_argument("--train-file", type=str, default="dry-bean-train.csv")
   parser.add_argument("--test-file", type=str, default="dry-bean-test.csv")
   args, _ = parser.parse_known_args()

Kemudian, kita membuat objek argument parser untuk membaca argumen baris perintah. Seperti disebutkan, nilai apa pun yang mungkin diperbarui di masa depan harus diteruskan sebagai argumen CLI. Bagian ini mendefinisikan argumen-argumen tersebut:

• Dua hiperparameter untuk objek Random Forest Classifier.
• Lima path file input dan output, termasuk artefak model dan file dataset.

Jika Anda memperhatikan nilai default direktori model-dir, train, dan test, Anda akan melihat beberapa variabel lingkungan. Nilai tersebut diambil dari dokumentasi SDK SageMaker, yang juga memberikan panduan untuk menulis file skrip seperti ini.

print("reading data")
train_df = pd.read_csv(os.path.join(args.train, args.train_file))
test_df = pd.read_csv(os.path.join(args.test, args.test_file))
print("building training and testing datasets")
X_train = train_df.drop("Class", axis=1)
X_test = test_df.drop("Class", axis=1)
y_train = train_df[["Class"]]
y_test = test_df[["Class"]]

Setelah kita mendefinisikan nilai dinamis, kita membaca dan membangun dataset pelatihan serta pengujian. Seperti yang terlihat, alih-alih memberikan path yang di-hardcode, kita menggunakan nilai args.argument.

# Train model
print("training model")
   
model = RandomForestClassifier(
    n_estimators=args.n_estimators,
    min_samples_leaf=args.min_samples_leaf,
    n_jobs=-1,
)

model.fit(X_train, y_train)

# Print abs error
print("validating model")
   
bal_acc_train = balanced_accuracy_score(y_train, model.predict(X_train))
bal_acc_test = balanced_accuracy_score(y_test, model.predict(X_test))

print(f"Train balanced accuracy: {bal_acc_train:.3f}")
print(f"Test balanced accuracy: {bal_acc_test:.3f}")

Kita memfitting model dan mengevaluasinya pada dataset pelatihan serta uji, lalu mencetak performanya.

# Persist model
path = os.path.join(args.model_dir, "model.joblib")
joblib.dump(model, path)
print("model persisted at " + path)

Terakhir, kita menyimpan model ke direktori model menggunakan joblib.

Saat Anda menjalankan sel ini di notebook, file script.py akan muncul di lingkungan JupyterLab Anda. Anda dapat memeriksa apakah ini berfungsi dengan benar dengan mengeksekusinya seperti di bawah ini:

! python script.py --n-estimators 100 \

                  --min-samples-leaf 2 \

                  --model-dir ./ \

                  --train ./ \

                  --test ./ \

extracting arguments

reading data

building training and testing datasets

validating model

Train balanced accuracy: 1.000

Test balanced accuracy: 0.998

model persisted at ./modejoblib

Bagus, kita mendapatkan skor balanced accuracy 99% — sudah sangat baik! Ini berarti kita akhirnya bisa memulai job pelatihan.

6. Membuat job pelatihan kustom di SageMaker

Sekarang, kita akan meneruskan skrip ke objek estimator SageMaker. Dalam konteks AWS, job pelatihan adalah proses di mana model dilatih menggunakan algoritme, dataset, dan resource komputasi yang ditentukan dan disediakan oleh AWS SageMaker. Berbeda dengan pelatihan di mesin lokal atau notebook, job ini berjalan di cloud pada infrastruktur berskala, sehingga memungkinkan daya komputasi lebih besar, pemrosesan lebih cepat, dan kemampuan menangani dataset yang lebih besar.

Tambahkan kode berikut pada sel baru di notebook Anda:

# We use the Estimator from the SageMaker Python SDK
from sagemaker.sklearn.estimator import SKLearn
FRAMEWORK_VERSION = "0.23-1"

sklearn_estimator = SKLearn(
   entry_point="script.py",
   role=get_execution_role(),
   instance_count=1,
   instance_type="ml.c5.xlarge",
   framework_version=FRAMEWORK_VERSION,
   base_job_name="rf-scikit",
   hyperparameters={
       "n-estimators": 100,
       "min-samples-leaf": 3,
   },
)

Pada kode di atas, kelas SKLearn menangani skrip scikit-learn. Ada beberapa parameter penting yang perlu dijelaskan:

• entry_point: Path ke skrip.
• role: Nama pengguna yang memiliki akses ke SageMaker.
• instance_count: Jumlah mesin yang akan dijalankan.
• instance_type: Jenis mesin.

Untuk hiperparameter, hanya teruskan yang Anda definisikan dalam skrip pelatihan. Jika tidak, akan terjadi error.

Sekarang, kita dapat melakukan fit estimator ini pada data kita:

# Launch training job, with asynchronous call
sklearn_estimator.fit({"train": trainpath, "test": testpath}, wait=True)

Jika Anda ingat dari bagian sebelumnya di tutorial ini, trainpath dan testpath adalah path bucket S3 yang menunjuk ke file CSV kita.

Setelah Anda menjalankan sel dengan kode di atas, pelatihan akan dimulai:

INFO:sagemaker:Creating training-job with name: rf-scikit-2024-06-04-10-36-31-142

2024-06-04 10:36:31 Starting - Starting the training job...

2024-06-04 10:36:46 Starting - Preparing the instances for training...

2024-06-04 10:37:13 Downloading - Downloading input data...

2024-06-04 10:37:53 Training - Training image download completed. Training in progress...

SageMaker mengunduh image Docker yang diperlukan agar Anda dapat menjalankan kode scikit-learn dan mengeksekusi skrip Anda. Setelah selesai, Anda akan mendapat pesan berikut:

2024-06-04 10:38:17 Uploading - Uploading generated training model

2024-06-04 10:38:17 Completed - Training job completed

Training seconds: 65

Billable seconds: 65

Jika Anda membuka bagian “SageMaker” > “Traning” > “Training Jobs” di dasbor SageMaker, Anda juga akan melihat job pelatihan tercantum di sana.

7. Menggunakan Spot Instances selama pelatihan untuk mengurangi biaya

Karena dataset kita kecil, kita bisa menggunakan mesin berbiaya rendah dan berkonfigurasi rendah untuk pelatihan: ml.c5.xlarge. Namun, dalam proyek Anda sendiri, Anda mungkin harus menangani dataset berisi jutaan rekaman atau dataset gambar yang masif. Dalam kasus tersebut, Anda harus memilih mesin yang menawarkan daya komputasi jauh lebih besar dan GPU.

Menggunakan mesin-mesin ini secara on demand dapat menjadi sangat mahal. Untuk menekan biaya, Amazon menawarkan Spot Training instances. Dengan instance tersebut, Anda dapat memilih resource komputasi bertenaga tinggi dengan harga rendah dengan satu catatan — pelatihan tidak akan langsung dimulai. Alih-alih, SageMaker menunggu hingga permintaan rendah dan mesin yang Anda minta tersedia.

Untuk mengaktifkan Spot Training, Anda hanya perlu menambahkan beberapa baris pada blok kode terakhir:

spot_sklearn_estimator = SKLearn(
   entry_point="script.py",
   role=get_execution_role(),
   instance_count=1,
   instance_type="ml.c5.xlarge",
   framework_version=FRAMEWORK_VERSION,
   base_job_name="rf-scikit",
   hyperparameters={
       "n-estimators": 100,
       "min-samples-leaf": 3,
   },
   use_spot_instances=True,
   max_wait=7200,
   max_run=3600,
)

Dengan menetapkan use_spot_instances ke True, Anda membuat spot_sklearn_estimator menggunakan spot training. Anda juga dapat mengatur waktu tunggu maksimum hingga instance spot tersedia dan durasi maksimum pelatihan berjalan.

Pelatihan benar-benar dimulai saat Anda memanggil .fit() lagi:

# Launch training job, with asynchronous call
spot_sklearn_estimator.fit({"train": trainpath, "test": testpath}, wait=True)

8. Penalaan hiperparameter menggunakan SageMaker

Dengan skrip pelatihan yang sama, kita dapat menghasilkan model yang dituning hiperparameternya dengan alur kerja serupa.

Pertama, kita mengimpor kelas IntegerParameter dari sagemaker.tuner:

from sagemaker.tuner import IntegerParameter

Kelas IntegerParameter memungkinkan SageMaker mendefinisikan rentang penalaan untuk parameter yang menerima nilai integer. Modul tuner berisi kelas untuk jenis parameter lainnya:

• CategoricalParameter: Mendefinisikan hiperparameter yang mengambil himpunan nilai kategorikal diskrit.
• ContinuousParameter: Mendefinisikan rentang penalaan untuk hiperparameter yang menerima nilai kontinu.

Namun, kita akan tetap menggunakan IntegerParameter dalam tutorial ini karena kita hanya menyetel dua parameter Random Forest:

# We use the Hyperparameter Tuner
from sagemaker.tuner import IntegerParameter

# Define exploration boundaries
hyperparameter_ranges = {
   "n-estimators": IntegerParameter(20, 100),
   "min-samples-leaf": IntegerParameter(2, 6),
}

Selanjutnya, kita membuat objek tuner:

# Create Optimizer
Optimizer = sagemaker.tuner.HyperparameterTuner(
   estimator=sklearn_estimator,
   hyperparameter_ranges=hyperparameter_ranges,
   base_tuning_job_name="RF-tuner",
   objective_type="Maximize",
   objective_metric_name="balanced-accuracy",
   metric_definitions=[
       {"Name": "balanced-accuracy", "Regex": "Test balanced accuracy: ([0-9.]+).*$"}
   ],  # Extract tracked metric from logs with regexp
   max_jobs=10,
   max_parallel_jobs=2,
)

Parameter penting Optimizer adalah:

• estimator: Objek estimator yang kompatibel dengan skrip pelatihan Anda.
• hyperparameter_ranges: Rentang parameter yang didefinisikan dengan kelas dari modul tuner.
• objective_type: Apakah memaksimalkan atau meminimalkan metrik yang diberikan. Balanced accuracy harus dimaksimalkan.
• metric_definitions: Nama metrik yang akan dioptimalkan dan bagaimana metrik tersebut diambil dari log pelatihan.

Parameter metric_definitions sedikit rumit karena menawarkan banyak fleksibilitas dalam cara Anda mendefinisikan metrik.

Dalam skrip pelatihan, kita melaporkan balanced accuracy menggunakan pesan log berikut:

print(f"Train balanced accuracy: {bal_acc_train:.3f}")
print(f"Test balanced accuracy: {bal_acc_test:.3f}")

Yang diminta oleh metric_definitions dari kita adalah menangkap pesan tersebut menggunakan regular expression. Jadi, kita memiliki kamus berikut, yang memberikan nama khusus pada metrik yang ditangkap yang dimulai dengan “Test balanced accuracy”.

{
   "Name": "balanced-accuracy",
   "Regex": "Test balanced accuracy: ([0-9.]+).*$",
}

Sisa kodenya sudah familier:

Optimizer.fit({"train": trainpath, "test": testpath})

INFO:sagemaker:Creating hyperparameter tuning job with name: RF-tuner-240604-1049

Setelah optimizer selesai melakukan penalaan, Anda dapat menampilkan hasilnya sebagai DataFrame:

# Get tuner results in a df
results = Optimizer.analytics().dataframe()

while results.empty:
   time.sleep(1)
   results = Optimizer.analytics().dataframe()

results.head()

Lalu, Anda dapat mengambil estimator terbaik:

best_estimator = Optimizer.best_estimator()

9. Menerapkan model ke endpoint di SageMaker

Setelah Anda memutuskan model mana yang akan digunakan untuk eksperimen Anda, Anda dapat mengunggahnya ke SageMaker beserta semua artefaknya. Tugas ini dapat dilakukan menggunakan boto3:

artifact_path = sm_boto3.describe_training_job(
   TrainingJobName=best_estimator.latest_training_job.name
)["ModelArtifacts"]["S3ModelArtifacts"]

print("Model artifact persisted at " + artifact)

Model artifact persisted at s3://sagemaker-us-east-1-496320894061/RF-tuner-240604-1049-009-38d75f35/output/model.tar.gz

Fungsi describe_training_job() mengambil objek estimator dan mendorongnya ke lokasi S3 default yang disediakan oleh SageMaker. Di atas, Anda dapat melihat bahwa fungsi tersebut mengonversi model menjadi tarball sebelum mengunggah.

Model yang diunggah akan terlihat di bagian “Inference” > “Models” pada dasbor SageMaker Anda:

Jika Anda mengeklik salah satunya, Anda akan melihat tombol “Create endpoint” di kanan atas layar:

Anda dapat menerapkan model menggunakan tombol tersebut, atau melakukannya dengan kode dengan kembali ke instance notebook dan menggunakan metode .deploy():

from sagemaker.sklearn.model import SKLearnModel

model = SKLearnModel(
   model_data=artifact_path,
   role=get_execution_role(),
   entry_point="script.py",
   framework_version=FRAMEWORK_VERSION,
)

Kali ini, kita menggunakan kelas SKLearnModel, yang digunakan untuk model yang sudah dilatih. Kelas ini memerlukan lokasi S3 tempat artefak disimpan dan skrip yang digunakan untuk melatihnya. Setelah Anda memberikan informasi tersebut, Anda dapat menjalankan kode untuk menerapkannya:

predictor = model.deploy(instance_type="ml.c5.large", initial_instance_count=1)
INFO:sagemaker:Creating model with name: sagemaker-scikit-learn-2024-06-04-11-03-54-465
INFO:sagemaker:Creating endpoint-config with name sagemaker-scikit-learn-2024-06-04-11-03-54-960
INFO:sagemaker:Creating endpoint with name sagemaker-scikit-learn-2024-06-04-11-03-54-960

Setelah itu, Anda akan melihat endpoint tercantum di bagian “Inference” > “Endpoints” pada dasbor SageMaker Anda:

Untuk menggunakannya dalam prediksi, Anda dapat menggunakan metode .predict() dari objek endpoint langsung dari notebook Anda:

preds = predictor.predict(test.sample(4).drop("Class", axis=1))
preds

array([3, 0, 1, 2])

Selamat, Anda baru saja menerapkan model pertama Anda dengan SageMaker!

Setelah selesai menggunakannya, jangan lupa menghapus endpoint tersebut, karena akan terus menimbulkan biaya:

sm_boto3.delete_endpoint(EndpointName=predictor.endpoint)

Jangan lupa, setiap instance notebook yang Anda buat di SageMaker dilengkapi tab terpisah berisi notebook contoh yang menampilkan berbagai fitur SageMaker:

Selain itu, lihat juga dokumentasi resmi untuk SageMaker Python SDK.

Kesimpulan

Hari ini, kita telah mempelajari cara menggunakan salah satu platform machine learning enterprise paling populer: AWS SageMaker. Kita telah membahas semuanya mulai dari membuat akun AWS hingga menerapkan model ML sebagai endpoint menggunakan SageMaker.

Seperti halnya platform lain, kita baru menggores permukaannya. Anda dapat melakukan jauh lebih banyak jika menggabungkannya dengan teknologi AWS lainnya dalam proyek Anda. Berikut beberapa sumber terkait untuk dibaca:

• Kursus Teknologi dan Layanan AWS
• Kursus Pengantar AWS
• Kursus Streaming Data dengan AWS Kinesis dan Lambda
• Panduan Komprehensif Menguasai AWS Step Functions