Hướng dẫn toàn tập về Machine Learning trên AWS với Amazon SageMaker

Mặc dù đa số mọi người biết đến Amazon với giao hàng nhanh và nội dung số, công ty này cũng được các nhà phát triển đánh giá rất cao. Cụ thể, Amazon Web Services (AWS) cung cấp công nghệ đám mây cho hơn 1 triệu người dùng hoạt động, bao gồm các tập đoàn doanh nghiệp và doanh nghiệp vừa và nhỏ.

Trong bài viết này, chúng ta sẽ tập trung vào AWS SageMaker — một nền tảng chuyên dụng để thực hiện các quy trình làm việc machine learning (ML) end-to-end ở quy mô lớn, nằm trong hệ sinh thái AWS. Kết thúc bài viết, chúng ta sẽ có một mô hình đã triển khai sẵn sàng nhận yêu cầu để tạo dự đoán cho một bài toán phân loại.

Amazon SageMaker là gì?

Amazon SageMaker là một dịch vụ được quản lý hoàn toàn, cung cấp công cụ và hạ tầng để xây dựng, huấn luyện và triển khai các mô hình machine learning. Dịch vụ này đơn giản hóa quy trình ML, giúp các nhà khoa học dữ liệu và nhà phát triển có thể tạo, huấn luyện và triển khai mô hình một cách nhanh chóng và hiệu quả.

Trong một dự án machine learning điển hình, bạn sẽ trải qua nhiều giai đoạn:

• Nạp dữ liệu, làm sạch và khám phá.
• Kỹ thuật đặc trưng và lựa chọn đặc trưng.
• Huấn luyện mô hình và tinh chỉnh siêu tham số.
• Triển khai và giám sát mô hình.

Mỗi giai đoạn yêu cầu một bộ công cụ khác nhau và một đội ngũ chuyên gia giàu kỹ năng để điều phối liền mạch. Amazon SageMaker đưa toàn bộ quy trình này vào một nền tảng duy nhất. Dưới đây là một số lợi ích:

• Dịch vụ machine learning end-to-end: Cung cấp bộ công cụ toàn diện cho mọi giai đoạn của vòng đời ML, từ chuẩn bị dữ liệu đến triển khai và giám sát mô hình.
• Môi trường phát triển tích hợp: SageMaker Studio cung cấp một IDE đơn giản hóa toàn bộ quy trình ML, cho phép người dùng xây dựng, huấn luyện và triển khai mô hình từ một giao diện duy nhất.
• Dễ sử dụng: Các tính năng như SageMaker Autopilot cho phép người dùng không có kinh nghiệm lập trình vẫn tạo ra mô hình chất lượng cao chỉ với vài cú nhấp chuột.
• Khả năng mở rộng: Tự động mở rộng hạ tầng để huấn luyện và triển khai mô hình, đảm bảo hiệu năng tối ưu mà không cần can thiệp thủ công.
• Tiết kiệm chi phí: Cung cấp các lựa chọn như Spot Training và multi-model endpoints để giảm chi phí huấn luyện và lưu trữ.
• Hỗ trợ các framework ML phổ biến: Cho phép nhà khoa học dữ liệu sử dụng các framework ưa thích như TensorFlow, PyTorch và XGBoost.
• Tự động tinh chỉnh siêu tham số: Tự động tinh chỉnh siêu tham số để tìm cấu hình mô hình có hiệu suất tốt nhất.
• Triển khai mô hình mạnh mẽ: Đơn giản hóa việc triển khai mô hình dưới dạng API thời gian thực hoặc dịch vụ dự đoán theo lô, giúp tích hợp mô hình ML vào ứng dụng dễ dàng.
• Giám sát toàn diện: SageMaker Model Monitor liên tục theo dõi hiệu suất mô hình, phát hiện sai lệch dữ liệu và bất thường trong môi trường sản xuất.
• Kho lưu trữ mô hình: Quản lý vòng đời mô hình ML, bao gồm tạo phiên bản, quy trình phê duyệt và lịch sử triển khai.
• Tích hợp liền mạch: Dễ dàng tích hợp với các dịch vụ AWS khác như Amazon S3 để lưu trữ dữ liệu, AWS Glue để chuẩn bị dữ liệu, AWS Lambda cho xử lý dựa trên sự kiện, và Amazon CloudWatch để giám sát và ghi log.
• Bảo mật và tuân thủ: Đảm bảo bảo vệ dữ liệu và tuân thủ các tiêu chuẩn ngành thông qua các tính năng bảo mật mạnh mẽ, bao gồm hỗ trợ VPC, mã hóa và chính sách IAM.

Những lợi ích này khiến Amazon SageMaker trở thành một nền tảng mạnh mẽ và linh hoạt để xây dựng, huấn luyện và triển khai mô hình machine learning ở quy mô lớn.

Thiết lập AWS Console và môi trường cho SageMaker

Như đã đề cập, SageMaker là một phần của hệ sinh thái AWS, bao gồm nhiều giải pháp điện toán đám mây cung cấp lưu trữ, mạng, cơ sở dữ liệu, phân tích và năng lực machine learning. Tất cả các giải pháp này hoạt động đồng bộ với SageMaker để hợp nhất quy trình ML của bạn.

Vì lý do đó, SageMaker yêu cầu bạn tạo một tài khoản AWS nếu bạn chưa có.

1. Tạo tài khoản AWS

Để tạo tài khoản, truy cập https://aws.amazon.com/ và làm theo quy trình để tạo tài khoản mới.

Quy trình đăng ký bao gồm thêm thông tin thanh toán và xác minh số điện thoại. Đừng lo — bạn sẽ không bị tính phí cho đến khi bạn thực sự bắt đầu sử dụng một số chức năng của SageMaker (thường khá tiết kiệm chi phí). 

Sau khi hoàn tất, bạn sẽ được chuyển đến AWS console của mình, thường trông như hình dưới đây. Lưu ý rằng một số widget trong console có thể khác trong trường hợp của bạn.

2. Tạo notebook instance

Bây giờ, chúng ta sẽ tạo một phiên JupyterLab để thực thi mã trên các máy chủ đám mây của Amazon.

Từ AWS console, tìm đến bảng điều khiển SageMaker bằng thanh tìm kiếm ở đầu màn hình:

Sau đó, cuộn xuống để tìm thẻ “Notebooks”, và bên trong là tùy chọn “Notebooks instances”. Bạn sẽ chưa thấy instance nào, nên chúng ta cần tạo một instance:

Để tạo notebook mới, nhấp vào “Create notebook instance” ở góc trên bên phải màn hình. Sau đó điền các trường sau:

• Đặt tên cho notebook của bạn. Ở đây, tôi đặt tên là sagemaker-test.
• Trường “Notebook instance type” chỉ định loại máy bạn muốn cho kernel của notebook. Tôi chọn ml.t3.large, máy có 8 GB RAM và 2 lõi CPU. Tại thời điểm viết bài, chi phí khoảng 0,12 USD/giờ (xem trang giá SageMaker để biết thông tin cập nhật).
• Trong mục “Permissions and encryption”, chọn tùy chọn “Create new user”, hệ thống sẽ tự động tạo một người dùng IAM với quyền cần thiết để chạy notebook instance.

Sau khi điền đầy đủ thông tin, nhấp “Create notebook instance”. 

Khi trạng thái “Pending” chuyển sang “inService”, bạn có thể khởi chạy JupyterLab bằng cách nhấp liên kết “Open in JupyterLab” cạnh notebook:

Ngay khi instance hoạt động, đồng hồ bắt đầu chạy và việc tính phí bắt đầu. Nếu bạn muốn tạm dừng, đừng quên dừng instance bằng cách nhấp “Actions” rồi “Stop” để tránh chi phí không cần thiết. Thời gian tự động tắt khi nhàn rỗi mặc định là hai giờ:

Nếu bạn dừng một notebook instance, bạn có thể khởi động lại sau. Môi trường của bạn sẽ được giữ nguyên.

Tải lên một bộ dữ liệu để sử dụng trong AWS SageMaker

Trong phần này, chúng ta sẽ học cách tải một tệp cục bộ lên máy chủ của Amazon, đây là yêu cầu để SageMaker có thể truy cập.

1. Tải xuống một bộ dữ liệu mẫu

Chúng ta sẽ xây dựng bộ phân loại đa lớp sử dụng bộ dữ liệu Dry Bean từ kho UCI ML. Bộ dữ liệu chứa 13 nghìn mẫu hạt đậu và 15 phép đo số của chúng. 

Nhiệm vụ là phân loại chúng thành bảy loại đậu: Seker, Barbunya, Bombay, Cali, Dermosan, Horoz và Sira.

Bảy loại đậu: Seker, Barbunya, Bombay, Cali, Dermosan, Horoz và Sira.

Sau khi tải xuống, lưu tệp Excel bên trong tệp ZIP vào thư mục dữ liệu cục bộ trong JupyterLab, rồi thêm đoạn mã sau vào notebook của bạn:

from pathlib import Path

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

Tiếp theo, bằng cách thêm đoạn mã sau, chúng ta có thể đọc tệp Excel với pandas và lưu thành CSV:

import pandas as pd

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

2. Tạo S3 bucket và tải dữ liệu lên

Bộ dữ liệu của chúng ta phải nằm trong một S3 bucket để SageMaker có thể truy cập. AWS S3 là giải pháp lưu trữ đám mây cho phép bạn lưu các đối tượng liên quan đến dự án trong các bucket được lưu trên máy chủ Amazon.

Để tạo bucket, thực hiện các bước sau:

• Đi tới S3 console. Bạn có thể tìm “S3” trong thanh tìm kiếm.
• Nhấp “Create bucket”.
• Đặt tên cho bucket của bạn.
• Tên bucket phải là duy nhất trên toàn cầu, nên bạn sẽ không thể dùng dry-bean-bucket như tôi đã dùng.
• Giữ nguyên cấu hình mặc định cho các trường còn lại.
• Nhấp “Create bucket”.

Sau khi tạo bucket, nhấp vào bucket để tải tệp CSV mà chúng ta đã lưu trước đó:

• Trong bucket, nhấp “Upload” rồi “Add files”.
• Chọn tệp CSV.
• Nhấp “Upload” lần nữa.

Sau đó, bạn có thể quay lại giao diện JupyterLab vì chúng ta sẽ bắt đầu chạy mã!

Quy trình huấn luyện và triển khai mô hình end-to-end trong AWS SageMaker

Trong phần này, chúng ta sẽ đi qua quy trình end-to-end đưa chúng ta từ bộ dữ liệu CSV đến một mô hình được triển khai tại endpoint. Nhưng trước khi đi sâu vào chi tiết kỹ thuật, hãy dành chút thời gian để hiểu bức tranh tổng thể về những gì chúng ta sẽ làm.

Tổng quan cấp cao về quy trình ML trong SageMaker

Thực hiện machine learning trong SageMaker hơi khác so với làm trên máy cục bộ. Chúng ta đã đề cập các bước đầu:

• Tạo tài khoản AWS.
• Tạo notebook instance.
• Tạo S3 bucket cho dự án.

Giống như notebook cục bộ, notebook instance của SageMaker dùng cho phân tích khám phá — làm sạch dữ liệu, khám phá, nạp dữ liệu và thử nghiệm cơ bản.

Khi bước vào giai đoạn huấn luyện mô hình, SageMaker mong bạn tuân theo một số quy tắc. Cụ thể, để SageMaker có thể triển khai mô hình tùy chỉnh của bạn thành endpoint, nó yêu cầu một script huấn luyện thực hiện những việc sau:

• Nạp dữ liệu từ nguồn.
• Huấn luyện một mô hình duy nhất trên dữ liệu.
• Lưu mô hình và các artifact.
• Báo cáo các chỉ số.

Script cũng phải động, chấp nhận mọi biến thông qua đối số dòng lệnh. Vì vậy, bất cứ thứ gì bạn muốn thay đổi trong tương lai bên trong script phải được thiết lập dưới dạng đối số dòng lệnh (siêu tham số mô hình, đường dẫn tệp, v.v.).

Khi script sẵn sàng, nó sẽ được đưa vào các estimator đặc biệt do SageMaker cung cấp. Đây là “bạn đồng hành” cho các thư viện ML phổ biến như scikit-learn, XGBoost, TensorFlow, PyTorch, v.v. Sử dụng những estimator này, SageMaker xây dựng các container Docker quanh script của bạn và triển khai nó thành endpoint để phục vụ ở quy mô lớn.

Tất cả các điểm trên sẽ trở nên rõ ràng khi chúng ta đi qua từng bước. 

1. Thiết lập notebook instance cho SageMaker

Bắt đầu bằng cách nhập các thư viện cần thiết trong notebook sagemaker-test bạn đã tạo trước đó:

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

Một số import trên có vai trò như sau:

• sagemaker là SDK Python chính thức giúp huấn luyện và triển khai mô hình ML trên Amazon SageMaker. Với SDK này, bạn có thể huấn luyện và triển khai mô hình dùng các framework học sâu phổ biến, các thuật toán do Amazon cung cấp, hoặc thuật toán riêng được đóng gói trong Docker tương thích SageMaker.
• boto3 là một SDK Python chính thức khác, nhưng đóng vai trò cầu nối giữa mã của bạn và mọi dịch vụ AWS, không chỉ riêng SageMaker. Bạn có thể tìm hiểu thêm về boto3 trong khóa học này. 

Sau khi import, hãy tạo một số tài nguyên chúng ta sẽ cần trong suốt hướng dẫn:

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

• Trong đoạn mã trên, đầu tiên chúng ta tạo một đối tượng client SageMaker bằng boto3. 
• Sau đó, tạo một phiên SageMaker. 

Cả hai đối tượng này cho phép chúng ta tương tác với nền tảng SageMaker theo những cách khác nhau.

Giờ hãy định nghĩa vài biến toàn cục cần dùng:

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"

Các biến này khá rõ nghĩa và sẽ được dùng xuyên suốt hướng dẫn.

2. Nạp dữ liệu từ S3 bucket vào SageMaker

Trong hầu hết dự án dữ liệu của bạn, tập dữ liệu huấn luyện sẽ được lưu trong giải pháp lưu trữ đám mây như BigQuery, GCS, hoặc một AWS S3 bucket. Chúng ta đã lưu ở lựa chọn cuối, nên hãy nạp bằng pandas. Thêm đoạn mã sau vào notebook và chạy:

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

Một ưu điểm khi làm việc trong notebook của Sagemaker là chúng ta có thể đọc tệp từ S3 trực tiếp bằng pandas. Mọi môi trường SageMaker đều được cấu hình với thông tin xác thực của bạn để cho phép pandas tải CSV từ bucket. Đoạn mã này sẽ không hoạt động nếu bạn chạy cục bộ.

3. Thực hiện EDA trong SageMaker

Dành thời gian cho EDA (Phân tích Khám phá Dữ liệu) là một phần bắt buộc của mọi dự án bạn làm, và ở đây cũng không ngoại lệ. Tuy nhiên, chúng ta sẽ không phân tích quá sâu để tránh làm lệch trọng tâm bài viết. 

Chúng ta sẽ in một vài thống kê tóm tắt và biểu đồ:

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

Thông tin trên cho biết có 16 đặc trưng số và một mục tiêu tên là Class. Bộ dữ liệu nhỏ, chỉ khoảng 13 nghìn mẫu, nên chúng ta sẽ không cần máy mạnh hay tốn nhiều chi phí để huấn luyện mô hình.

Tiếp theo, hãy tạo biểu đồ pair plot cho một vài đặc trưng quan trọng bằng seaborn:

import seaborn as sns

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

Các biểu đồ cho thấy các loại đậu khác biệt rõ ràng về các phép đo vật lý. Nhóm màu xanh lá (Bombay) đặc biệt tách biệt tốt.

Chúng ta cũng có thể vẽ ma trận tương quan để xem mối quan hệ giữa các đặc trưng:

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()

Biểu đồ cho thấy nhiều đặc trưng tương quan hoàn hảo (cùng và ngược chiều), điều này hợp lý vì tất cả đều liên quan đến phép đo vật lý.

Tại thời điểm này, tôi sẽ để bạn tiếp tục khám phá thêm.

4. Chuẩn bị dữ liệu để huấn luyện mô hình trong SageMaker

Sau giai đoạn khám phá, bạn cần xử lý mọi vấn đề chất lượng hay logic trong bộ dữ liệu và tạo đặc trưng mới nếu cần trước khi huấn luyện. 

Bộ dữ liệu Dry Bean khá sạch, nên công việc của chúng ta đơn giản. Ta chỉ cần mã hóa biến mục tiêu vì nó là dạng văn bản. Chúng ta sẽ dùng scikit-learn để thực hiện:

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])

Sau khi tiền xử lý xong, chúng ta cần chia bộ dữ liệu:

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)

Bạn có thể chia thêm thành một tập validation thứ ba nếu muốn, nhưng ở đây ta giữ mọi thứ đơn giản.

Giờ hãy lưu các tập dữ liệu thành CSV:

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

Và tải chúng lên S3 bucket của chúng ta:

# 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",
)

Hàm .upload_data() của đối tượng session trả về đường dẫn đầy đủ đến tệp đã tải lên, được lưu trong biến trainpath và testpath tương ứng. Chúng ta sẽ dùng các đường dẫn này sau.

5. Viết script huấn luyện cho SageMaker

Trong một ô notebook mới, dán đoạn mã sau:

%%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)

Lệnh magic %%writefile script.py trong script trên sẽ chuyển nội dung ô thành một tệp Python thay vì chạy nó.

Giờ hãy đi qua từng bước trong script đang diễn ra:

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

Đầu tiên, chúng ta import một số thư viện cần thiết. 

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()

Sau đó, chúng ta tạo một đối tượng phân tích đối số để đọc tham số dòng lệnh. Như đã đề cập, mọi giá trị có thể cập nhật trong tương lai phải được truyền qua CLI. Phần này định nghĩa các đối số đó:

• Hai siêu tham số cho đối tượng Random Forest Classifier.
• Năm đường dẫn tệp vào/ra, bao gồm artifact của mô hình và các tệp dữ liệu.

Nếu bạn để ý các giá trị mặc định của thư mục model-dir, train và test, bạn sẽ thấy một số biến môi trường. Chúng được lấy từ tài liệu SDK SageMaker, nơi cũng hướng dẫn cách viết các tệp script như vậy.

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"]]

Sau khi xác định các giá trị động, chúng ta đọc và xây dựng các tập huấn luyện và kiểm thử. Như bạn thấy, thay vì truyền đường dẫn cố định, chúng ta dùng các giá trị 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}")

Chúng ta fit mô hình và đánh giá trên cả tập huấn luyện và kiểm thử rồi in hiệu suất. 

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

Cuối cùng, chúng ta lưu mô hình vào thư mục model bằng joblib.

Khi chạy ô này trong notebook, tệp script.py sẽ xuất hiện trong môi trường JupyterLab của bạn. Bạn có thể kiểm tra hoạt động bằng cách thực thi như sau:

! 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

Tuyệt vời, chúng ta đạt 99% balanced accuracy — gần như tối đa! Điều này có nghĩa chúng ta có thể bắt đầu một training job.

6. Tạo training job tùy chỉnh trong SageMaker

Giờ chúng ta sẽ truyền script vào một đối tượng estimator của SageMaker. Trong bối cảnh AWS, một training job là tiến trình huấn luyện mô hình bằng thuật toán, tập dữ liệu và tài nguyên tính toán do AWS SageMaker cung cấp. Khác với huấn luyện trên máy cục bộ hoặc notebook, job này chạy trên đám mây với hạ tầng có thể mở rộng, cho phép nhiều sức mạnh tính toán hơn, xử lý nhanh hơn và khả năng xử lý tập dữ liệu lớn.

Thêm đoạn mã sau vào một ô mới trong notebook của bạn:

# 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,
   },
)

Trong đoạn mã trên, lớp SKLearn xử lý các script của scikit-learn. Nó có một vài tham số quan trọng cần giải thích:

• entry_point: Đường dẫn đến script.
• role: Tên người dùng có quyền truy cập SageMaker.
• instance_count: Số lượng máy sẽ khởi tạo.
• instance_type: Loại máy.

Với siêu tham số, chỉ truyền những tham số bạn đã định nghĩa trong script huấn luyện. Nếu không sẽ gặp lỗi. 

Bây giờ, chúng ta có thể fit estimator này với dữ liệu:

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

Như đã nhắc ở phần trước của hướng dẫn, trainpath và testpath là đường dẫn S3 trỏ đến các tệp CSV của chúng ta. 

Khi chạy ô mã trên, quá trình huấn luyện bắt đầu:

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 tải image Docker cần thiết để chạy mã scikit-learn và thực thi script của bạn. Khi hoàn tất, bạn sẽ nhận được thông báo sau:

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

Nếu bạn vào mục “SageMaker” > “Traning” > “Training Jobs” trong bảng điều khiển SageMaker, bạn cũng sẽ thấy training job được liệt kê ở đó.

7. Sử dụng Spot Instances trong quá trình huấn luyện để giảm chi phí

Vì bộ dữ liệu của chúng ta nhỏ, chúng ta có thể dùng một máy cấu hình thấp, chi phí thấp để huấn luyện :  ml.c5.xlarge. Tuy nhiên, trong các dự án riêng của bạn, có thể bạn phải xử lý các bộ dữ liệu có hàng triệu bản ghi hoặc bộ ảnh khổng lồ. Khi đó, bạn cần chọn máy có sức mạnh đáng kể hơn và có GPU.

Sử dụng các máy này theo nhu cầu có thể rất đắt đỏ. Để cắt giảm chi phí, Amazon cung cấp Spot Training instances. Với những instance này, bạn có thể chọn tài nguyên tính toán mạnh với mức giá thấp nhưng có một điều kiện — quá trình huấn luyện sẽ không bắt đầu ngay lập tức. Thay vào đó, SageMaker sẽ đợi đến khi nhu cầu giảm và máy bạn yêu cầu sẵn có. 

Để bật Spot Training, bạn chỉ cần thêm vài dòng vào khối mã cuối:

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,
)

Khi đặt use_spot_instances thành True, bạn khiến spot_sklearn_estimator sử dụng spot training. Bạn cũng có thể đặt thời gian chờ tối đa để spot instance sẵn sàng và thời gian chạy tối đa cho quá trình huấn luyện. 

Việc huấn luyện thực sự bắt đầu khi bạn gọi lại .fit():

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

8. Tinh chỉnh siêu tham số bằng SageMaker

Dùng cùng một script huấn luyện, chúng ta có thể tạo một mô hình đã được tinh chỉnh siêu tham số với quy trình tương tự. 

Đầu tiên, import lớp IntegerParameter từ sagemaker.tuner:

from sagemaker.tuner import IntegerParameter

Lớp IntegerParameter cho phép SageMaker định nghĩa khoảng tinh chỉnh cho các tham số nhận giá trị số nguyên. Module tuner còn chứa các lớp cho kiểu tham số khác:

• CategoricalParameter: Định nghĩa siêu tham số nhận một tập giá trị phân loại rời rạc.
• ContinuousParameter: Định nghĩa khoảng tinh chỉnh cho siêu tham số nhận giá trị liên tục.

Nhưng trong hướng dẫn này, chúng ta chỉ dùng IntegerParameter vì chỉ tinh chỉnh hai tham số của 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),
}

Sau đó, tạo một đối tượng 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,
)

Các tham số quan trọng của Optimizer là:

• estimator: Đối tượng estimator tương thích với script huấn luyện của bạn.
• hyperparameter_ranges: Phạm vi các tham số được định nghĩa bằng các lớp trong module tuner.
• objective_type: Tối đa hóa hay tối thiểu hóa chỉ số cho trước. Balanced accuracy cần được tối đa hóa.
• metric_definitions: Tên các chỉ số cần tối ưu và cách trích xuất chúng từ log huấn luyện.

Tham số metric_definitions hơi “khoai” vì nó rất linh hoạt trong cách bạn định nghĩa chỉ số. 

Trong script huấn luyện, chúng ta báo cáo balanced accuracy bằng thông điệp log sau:

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

Yêu cầu của metric_definitions là chúng ta phải bắt được thông điệp này bằng biểu thức chính quy. Vì vậy, ta có từ điển sau, đặt tên tùy chỉnh cho chỉ số được bắt đầu bằng “Test balanced accuracy”.

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

Phần còn lại của mã thì quen thuộc:

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

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

Khi optimizer hoàn tất tinh chỉnh, bạn có thể hiển thị kết quả dưới dạng DataFrame:

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

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

results.head()

Sau đó, bạn có thể lấy estimator tốt nhất:

best_estimator = Optimizer.best_estimator()

9. Triển khai mô hình lên endpoint trong SageMaker 

Khi bạn quyết định mô hình nào sẽ dùng cho thử nghiệm, bạn có thể tải nó lên SageMaker cùng toàn bộ artifact. Tác vụ này có thể thực hiện bằng 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

Hàm describe_training_job() nhận một đối tượng estimator và đẩy nó lên vị trí S3 mặc định do SageMaker cung cấp. Ở trên, bạn có thể thấy hàm đã chuyển mô hình thành một tarball trước khi tải lên.

Các mô hình đã tải lên sẽ hiển thị dưới mục “Inference” > “Models” trong bảng điều khiển SageMaker của bạn:

Nếu bạn nhấp vào bất kỳ mô hình nào, bạn sẽ thấy nút “Create endpoint” ở góc trên bên phải màn hình:

Bạn có thể triển khai mô hình bằng nút đó, hoặc làm bằng mã bằng cách quay lại notebook instance và dùng phương thức .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,
)

Lần này, chúng ta dùng lớp SKLearnModel, dùng cho các mô hình đã huấn luyện xong. Nó yêu cầu vị trí S3 lưu artifact và script dùng để huấn luyện. Sau khi cung cấp thông tin, bạn có thể chạy mã để triển khai:

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

Sau đó, bạn sẽ thấy endpoint xuất hiện dưới mục “Inference” > “Endpoints” trong bảng điều khiển SageMaker:

Để dùng cho dự đoán, bạn có thể gọi phương thức .predict() của đối tượng endpoint từ notebook:

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

array([3, 0, 1, 2])
Chúc mừng, bạn vừa triển khai mô hình đầu tiên với SageMaker!
Khi dùng xong, đừng quên xóa endpoint, vì nó sẽ liên tục phát sinh chi phí:
sm_boto3.delete_endpoint(EndpointName=predictor.endpoint)
Đừng quên, mỗi notebook instance bạn tạo trong SageMaker đều có một thẻ riêng chứa các notebook mẫu trình bày các tính năng khác nhau của SageMaker:

Ngoài ra, hãy xem thêm tài liệu chính thức cho SageMaker Python SDK.
Kết luận
Hôm nay, chúng ta đã học cách sử dụng một trong những nền tảng machine learning cho doanh nghiệp phổ biến nhất :  AWS SageMaker. Chúng ta đã đi từ việc tạo tài khoản AWS đến triển khai mô hình ML thành endpoint bằng SageMaker.
Cũng như bất kỳ nền tảng nào, chúng ta mới chỉ lướt qua bề mặt. Bạn có thể làm được nhiều hơn nữa nếu kết hợp với các công nghệ AWS khác trong dự án của mình. Dưới đây là một số tài nguyên liên quan nên tham khảo:

Khóa học Công nghệ và Dịch vụ AWS
Khóa học Nhập môn AWS
Khóa học Streaming Data với AWS Kinesis và Lambda
Hướng dẫn toàn diện để làm chủ AWS Step Functions