1. Tổng quan
Trong phòng thí nghiệm này, bạn sẽ sử dụng Vertex AI để huấn luyện và phân phát một mô hình TensorFlow bằng mã trong một vùng chứa tuỳ chỉnh.
Mặc dù chúng ta đang sử dụng TensorFlow cho mã mô hình ở đây, nhưng bạn có thể dễ dàng thay thế bằng một khung khác.
Kiến thức bạn sẽ học được
Bạn sẽ tìm hiểu cách:
- Xây dựng và chứa mã huấn luyện mô hình trong Vertex Workbench
- Gửi một quy trình huấn luyện mô hình tuỳ chỉnh đến Vertex AI
- Triển khai mô hình đã huấn luyện vào một điểm cuối và sử dụng điểm cuối đó để nhận dự đoán
Tổng chi phí để chạy bài tập thực hành này trên Google Cloud là khoảng 1 USD.
2. Giới thiệu về Vertex AI
Phòng thí nghiệm này sử dụng sản phẩm AI mới nhất hiện có trên Google Cloud. Vertex AI tích hợp các sản phẩm ML trên Google Cloud thành một trải nghiệm phát triển liền mạch. Trước đây, các mô hình được huấn luyện bằng AutoML và các mô hình tuỳ chỉnh có thể truy cập thông qua các dịch vụ riêng biệt. Sản phẩm mới này kết hợp cả hai thành một API duy nhất, cùng với các sản phẩm mới khác. Bạn cũng có thể di chuyển các dự án hiện có sang Vertex AI. Nếu bạn có ý kiến phản hồi, vui lòng truy cập trang hỗ trợ.
Vertex AI có nhiều sản phẩm để hỗ trợ quy trình làm việc ML toàn diện. Phòng thí nghiệm này sẽ tập trung vào các sản phẩm được làm nổi bật bên dưới: Đào tạo, Dự đoán và Workbench.
3. Thiết lập môi trường
Bạn cần có một dự án trên Google Cloud Platform đã bật tính năng thanh toán để chạy lớp học lập trình này. Để tạo một dự án, hãy làm theo hướng dẫn tại đây.
Bước 1: Bật Compute Engine API
Chuyển đến Compute Engine rồi chọn Bật nếu bạn chưa bật. Bạn sẽ cần thông tin này để tạo thực thể sổ tay.
Bước 2: Bật Vertex AI API
Chuyển đến mục Vertex AI trong Bảng điều khiển Cloud rồi nhấp vào Bật Vertex AI API.
Bước 3: Bật Container Registry API
Chuyển đến Container Registry rồi chọn Bật nếu bạn chưa bật. Bạn sẽ dùng thông tin này để tạo một vùng chứa cho công việc huấn luyện tuỳ chỉnh.
Bước 4: Tạo một phiên bản Vertex AI Workbench
Trong phần Vertex AI của Cloud Console, hãy nhấp vào Workbench:
Tại đó, trong phần Notebooks do người dùng quản lý, hãy nhấp vào New Notebook (Sổ tay mới):
Sau đó, hãy chọn phiên bản mới nhất của loại thực thể TensorFlow Enterprise (có LTS) không có GPU:
Sử dụng các lựa chọn mặc định rồi nhấp vào Tạo.
Mô hình mà chúng ta sẽ huấn luyện và phân phát trong phòng thí nghiệm này được xây dựng dựa trên hướng dẫn này trong tài liệu TensorFlow. Hướng dẫn này sử dụng tập dữ liệu Auto MPG từ Kaggle để dự đoán hiệu suất nhiên liệu của một chiếc xe.
4. Chứa mã huấn luyện
Chúng ta sẽ gửi công việc huấn luyện này đến Vertex bằng cách đặt mã huấn luyện vào một vùng chứa Docker và đẩy vùng chứa này đến Google Container Registry. Bằng cách sử dụng phương pháp này, chúng ta có thể huấn luyện một mô hình được xây dựng bằng bất kỳ khung nào.
Để bắt đầu, từ trình đơn Trình chạy, hãy mở cửa sổ dòng lệnh trong phiên bản sổ tay của bạn:
Tạo một thư mục mới có tên là mpg rồi chuyển đến thư mục đó:
mkdir mpg
cd mpg
Bước 1: Tạo một Dockerfile
Bước đầu tiên trong việc chứa mã của chúng ta là tạo một Dockerfile. Trong Dockerfile, chúng ta sẽ thêm tất cả các lệnh cần thiết để chạy hình ảnh. Thao tác này sẽ cài đặt tất cả các thư viện mà chúng ta đang sử dụng và thiết lập điểm truy cập cho mã huấn luyện. Trên thiết bị đầu cuối, hãy tạo một Dockerfile trống:
touch Dockerfile
Mở Dockerfile rồi sao chép nội dung sau vào đó:
FROM gcr.io/deeplearning-platform-release/tf2-cpu.2-6
WORKDIR /
# Copies the trainer code to the docker image.
COPY trainer /trainer
# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "-m", "trainer.train"]
Dockerfile này sử dụng hình ảnh Docker Deep Learning Container TensorFlow Enterprise 2.3. Deep Learning Containers trên Google Cloud được cài đặt sẵn nhiều khung học máy và khoa học dữ liệu phổ biến. Chúng tôi đang sử dụng TF Enterprise 2.3, Pandas, Scikit-learn và những thư viện khác. Sau khi tải hình ảnh đó xuống, Dockerfile này sẽ thiết lập điểm truy cập cho mã huấn luyện của chúng ta. Chúng ta chưa tạo các tệp này. Trong bước tiếp theo, chúng ta sẽ thêm mã để huấn luyện và xuất mô hình.
Bước 2: Tạo một bộ chứa Cloud Storage
Trong quy trình huấn luyện, chúng ta sẽ xuất mô hình TensorFlow đã huấn luyện sang một bộ chứa Cloud Storage. Vertex sẽ dùng thông tin này để đọc các thành phần mô hình đã xuất và triển khai mô hình. Trong Terminal, hãy chạy lệnh sau để xác định một biến môi trường cho dự án của bạn, nhớ thay thế your-cloud-project bằng mã dự án:
PROJECT_ID='your-cloud-project'
Tiếp theo, hãy chạy lệnh sau trong Terminal để tạo một nhóm mới trong dự án của bạn. Cờ -l (vị trí) rất quan trọng vì cờ này phải nằm trong cùng khu vực nơi bạn triển khai một điểm cuối mô hình sau này trong hướng dẫn:
BUCKET_NAME="gs://${PROJECT_ID}-bucket"
gsutil mb -l us-central1 $BUCKET_NAME
Bước 3: Thêm mã huấn luyện mô hình
Trong Terminal, hãy chạy lệnh sau để tạo một thư mục cho mã huấn luyện và một tệp Python nơi chúng ta sẽ thêm mã:
mkdir trainer
touch trainer/train.py
Giờ đây, bạn sẽ có những nội dung sau trong thư mục mpg/:
+ Dockerfile
+ trainer/
+ train.py
Tiếp theo, hãy mở tệp train.py bạn vừa tạo rồi sao chép mã bên dưới (mã này được điều chỉnh từ hướng dẫn trong tài liệu TensorFlow).
Khi bắt đầu tệp, hãy cập nhật biến BUCKET bằng tên của Bộ chứa lưu trữ mà bạn đã tạo ở bước trước:
import numpy as np
import pandas as pd
import pathlib
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
print(tf.__version__)
"""## The Auto MPG dataset
The dataset is available from the [UCI Machine Learning Repository](https://archive.ics.uci.edu/ml/).
### Get the data
First download the dataset.
"""
dataset_path = keras.utils.get_file("auto-mpg.data", "http://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data")
dataset_path
"""Import it using pandas"""
column_names = ['MPG','Cylinders','Displacement','Horsepower','Weight',
'Acceleration', 'Model Year', 'Origin']
dataset = pd.read_csv(dataset_path, names=column_names,
na_values = "?", comment='\t',
sep=" ", skipinitialspace=True)
dataset.tail()
# TODO: replace `your-gcs-bucket` with the name of the Storage bucket you created earlier
BUCKET = 'gs://your-gcs-bucket'
"""### Clean the data
The dataset contains a few unknown values.
"""
dataset.isna().sum()
"""To keep this initial tutorial simple drop those rows."""
dataset = dataset.dropna()
"""The `"Origin"` column is really categorical, not numeric. So convert that to a one-hot:"""
dataset['Origin'] = dataset['Origin'].map({1: 'USA', 2: 'Europe', 3: 'Japan'})
dataset = pd.get_dummies(dataset, prefix='', prefix_sep='')
dataset.tail()
"""### Split the data into train and test
Now split the dataset into a training set and a test set.
We will use the test set in the final evaluation of our model.
"""
train_dataset = dataset.sample(frac=0.8,random_state=0)
test_dataset = dataset.drop(train_dataset.index)
"""### Inspect the data
Have a quick look at the joint distribution of a few pairs of columns from the training set.
Also look at the overall statistics:
"""
train_stats = train_dataset.describe()
train_stats.pop("MPG")
train_stats = train_stats.transpose()
train_stats
"""### Split features from labels
Separate the target value, or "label", from the features. This label is the value that you will train the model to predict.
"""
train_labels = train_dataset.pop('MPG')
test_labels = test_dataset.pop('MPG')
"""### Normalize the data
Look again at the `train_stats` block above and note how different the ranges of each feature are.
It is good practice to normalize features that use different scales and ranges. Although the model *might* converge without feature normalization, it makes training more difficult, and it makes the resulting model dependent on the choice of units used in the input.
Note: Although we intentionally generate these statistics from only the training dataset, these statistics will also be used to normalize the test dataset. We need to do that to project the test dataset into the same distribution that the model has been trained on.
"""
def norm(x):
return (x - train_stats['mean']) / train_stats['std']
normed_train_data = norm(train_dataset)
normed_test_data = norm(test_dataset)
"""This normalized data is what we will use to train the model.
Caution: The statistics used to normalize the inputs here (mean and standard deviation) need to be applied to any other data that is fed to the model, along with the one-hot encoding that we did earlier. That includes the test set as well as live data when the model is used in production.
## The model
### Build the model
Let's build our model. Here, we'll use a `Sequential` model with two densely connected hidden layers, and an output layer that returns a single, continuous value. The model building steps are wrapped in a function, `build_model`, since we'll create a second model, later on.
"""
def build_model():
model = keras.Sequential([
layers.Dense(64, activation='relu', input_shape=[len(train_dataset.keys())]),
layers.Dense(64, activation='relu'),
layers.Dense(1)
])
optimizer = tf.keras.optimizers.RMSprop(0.001)
model.compile(loss='mse',
optimizer=optimizer,
metrics=['mae', 'mse'])
return model
model = build_model()
"""### Inspect the model
Use the `.summary` method to print a simple description of the model
"""
model.summary()
"""Now try out the model. Take a batch of `10` examples from the training data and call `model.predict` on it.
It seems to be working, and it produces a result of the expected shape and type.
### Train the model
Train the model for 1000 epochs, and record the training and validation accuracy in the `history` object.
Visualize the model's training progress using the stats stored in the `history` object.
This graph shows little improvement, or even degradation in the validation error after about 100 epochs. Let's update the `model.fit` call to automatically stop training when the validation score doesn't improve. We'll use an *EarlyStopping callback* that tests a training condition for every epoch. If a set amount of epochs elapses without showing improvement, then automatically stop the training.
You can learn more about this callback [here](https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/EarlyStopping).
"""
model = build_model()
EPOCHS = 1000
# The patience parameter is the amount of epochs to check for improvement
early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', patience=10)
early_history = model.fit(normed_train_data, train_labels,
epochs=EPOCHS, validation_split = 0.2,
callbacks=[early_stop])
# Export model and save to GCS
model.save(BUCKET + '/mpg/model')
Bước 4: Tạo và kiểm thử vùng chứa cục bộ
Từ Terminal, hãy xác định một biến bằng URI của hình ảnh vùng chứa trong Google Container Registry:
IMAGE_URI="gcr.io/$PROJECT_ID/mpg:v1"
Sau đó, hãy tạo vùng chứa bằng cách chạy lệnh sau từ gốc của thư mục mpg:
docker build ./ -t $IMAGE_URI
Chạy vùng chứa trong phiên bản sổ tay để đảm bảo vùng chứa hoạt động chính xác:
docker run $IMAGE_URI
Mô hình sẽ hoàn tất quá trình huấn luyện trong 1-2 phút với độ chính xác xác thực khoảng 72% (độ chính xác thực tế có thể khác). Sau khi chạy vùng chứa cục bộ xong, hãy đẩy vùng chứa đó lên Google Container Registry:
docker push $IMAGE_URI
Sau khi đẩy vùng chứa lên Container Registry, chúng ta đã sẵn sàng bắt đầu một quy trình huấn luyện mô hình tuỳ chỉnh.
5. Chạy một quy trình huấn luyện trên Vertex AI
Vertex AI cung cấp cho bạn 2 lựa chọn để huấn luyện mô hình:
- AutoML: Huấn luyện các mô hình chất lượng cao mà chỉ cần rất ít công sức và chuyên môn về học máy.
- Huấn luyện tuỳ chỉnh: Chạy các ứng dụng huấn luyện tuỳ chỉnh của bạn trên đám mây bằng một trong các vùng chứa được tạo sẵn của Google Cloud hoặc sử dụng vùng chứa của riêng bạn.
Trong phòng thí nghiệm này, chúng ta sẽ sử dụng hoạt động huấn luyện tuỳ chỉnh thông qua vùng chứa tuỳ chỉnh của riêng mình trên Google Container Registry. Để bắt đầu, hãy chuyển đến phần Mô hình trong phần Vertex của bảng điều khiển Cloud:
Bước 1: Bắt đầu công việc huấn luyện
Nhấp vào Tạo để nhập các tham số cho mô hình được triển khai và công việc huấn luyện của bạn:
- Trong mục Tập dữ liệu, hãy chọn Không có tập dữ liệu được quản lý
- Sau đó, hãy chọn Khoá huấn luyện tuỳ chỉnh (nâng cao) làm phương pháp huấn luyện rồi nhấp vào Tiếp tục.
- Nhấp vào Tiếp tục
Trong bước tiếp theo, hãy nhập mpg (hoặc bất kỳ tên nào bạn muốn đặt cho mô hình) cho Tên mô hình. Sau đó, hãy chọn Vùng chứa tuỳ chỉnh:
Trong hộp văn bản Container image (Hình ảnh vùng chứa), hãy nhấp vào Browse (Duyệt qua) rồi tìm hình ảnh Docker mà bạn vừa tải lên Container Registry. Để trống các trường còn lại rồi nhấp vào Tiếp tục.
Chúng ta sẽ không sử dụng tính năng điều chỉnh siêu tham số trong hướng dẫn này, vì vậy, hãy bỏ đánh dấu hộp Bật tính năng điều chỉnh siêu tham số rồi nhấp vào Tiếp tục.
Trong phần Điện toán và giá, hãy giữ nguyên khu vực đã chọn và chọn n1-standard-4 làm loại máy:
Để trống các trường về bộ tăng tốc rồi chọn Tiếp tục. Vì mô hình trong bản minh hoạ này huấn luyện nhanh chóng, nên chúng ta sẽ sử dụng một loại máy nhỏ hơn.
Trong bước Vùng chứa dự đoán, hãy chọn Vùng chứa dựng sẵn rồi chọn TensorFlow 2.6.
Giữ nguyên chế độ cài đặt mặc định cho vùng chứa được tạo sẵn. Trong Model directory (Thư mục mô hình), hãy nhập vùng chứa GCS của bạn có thư mục con mpg. Đây là đường dẫn trong tập lệnh huấn luyện mô hình, nơi bạn xuất mô hình đã huấn luyện:
Vertex sẽ tìm kiếm ở vị trí này khi triển khai mô hình của bạn. Giờ thì bạn đã sẵn sàng tham gia khoá huấn luyện! Nhấp vào Bắt đầu huấn luyện để bắt đầu công việc huấn luyện. Trong phần Huấn luyện của bảng điều khiển, bạn sẽ thấy nội dung như sau:
6. Triển khai một điểm cuối mô hình
Khi thiết lập quy trình huấn luyện, chúng ta đã chỉ định vị trí mà Vertex AI nên tìm kiếm các thành phần mô hình đã xuất. Trong quy trình huấn luyện của chúng tôi, Vertex sẽ tạo một tài nguyên mô hình dựa trên đường dẫn tài sản này. Bản thân tài nguyên mô hình không phải là một mô hình được triển khai, nhưng sau khi có một mô hình, bạn có thể triển khai mô hình đó đến một điểm cuối. Để tìm hiểu thêm về Mô hình và Điểm cuối trong Vertex AI, hãy xem tài liệu.
Trong bước này, chúng ta sẽ tạo một điểm cuối cho mô hình đã huấn luyện. Chúng ta có thể sử dụng phương thức này để nhận kết quả dự đoán về mô hình thông qua Vertex AI API.
Bước 1: Triển khai điểm cuối
Khi hoàn tất quy trình huấn luyện, bạn sẽ thấy một mô hình có tên là mpg (hoặc tên bạn đặt) trong phần Mô hình của bảng điều khiển:
Khi bạn chạy quy trình huấn luyện, Vertex sẽ tạo một tài nguyên mô hình cho bạn. Để sử dụng mô hình này, bạn cần triển khai một điểm cuối. Bạn có thể có nhiều điểm cuối cho mỗi mô hình. Nhấp vào mô hình rồi nhấp vào Triển khai đến điểm cuối.
Chọn Tạo điểm cuối mới rồi đặt tên cho điểm cuối đó, chẳng hạn như v1. Chọn Tiêu chuẩn cho Quyền truy cập, rồi nhấp vào Tiếp tục.
Để mức phân tách lưu lượng truy cập ở mức 100 và nhập 1 cho Số lượng tối thiểu của các nút tính toán. Trong phần Loại máy, hãy chọn n1-standard-2 (hoặc bất kỳ loại máy nào bạn muốn). Để nguyên các chế độ cài đặt mặc định còn lại, rồi nhấp vào Tiếp tục. Chúng ta sẽ không bật tính năng giám sát cho mô hình này, vì vậy, hãy nhấp vào Triển khai để bắt đầu triển khai điểm cuối.
Việc triển khai điểm cuối sẽ mất từ 10 đến 15 phút và bạn sẽ nhận được email khi quá trình triển khai hoàn tất. Khi điểm cuối đã triển khai xong, bạn sẽ thấy nội dung sau đây, cho biết một điểm cuối được triển khai trong tài nguyên Mô hình của bạn:
Bước 2: Nhận kết quả dự đoán về mô hình đã triển khai
Chúng ta sẽ nhận được kết quả dự đoán về mô hình đã huấn luyện từ một sổ tay Python, bằng cách sử dụng Vertex Python API. Quay lại phiên bản sổ tay của bạn rồi tạo một sổ tay Python 3 trong Trình chạy:
Trong sổ tay, hãy chạy nội dung sau trong một ô để cài đặt Vertex AI SDK:
!pip3 install google-cloud-aiplatform --upgrade --user
Sau đó, hãy thêm một ô vào sổ tay của bạn để nhập SDK và tạo một thông tin tham chiếu đến điểm cuối mà bạn vừa triển khai:
from google.cloud import aiplatform
endpoint = aiplatform.Endpoint(
endpoint_name="projects/YOUR-PROJECT-NUMBER/locations/us-central1/endpoints/YOUR-ENDPOINT-ID"
)
Bạn sẽ cần thay thế 2 giá trị trong chuỗi endpoint_name ở trên bằng số dự án và điểm cuối của bạn. Bạn có thể tìm thấy số dự án bằng cách chuyển đến trang tổng quan dự án và lấy giá trị Số dự án.
Bạn có thể tìm thấy mã nhận dạng thiết bị đầu cuối trong phần thiết bị đầu cuối của bảng điều khiển tại đây:
Cuối cùng, hãy đưa ra dự đoán cho điểm cuối của bạn bằng cách sao chép và chạy mã bên dưới trong một ô mới:
test_mpg = [1.4838871833555929,
1.8659883497083019,
2.234620276849616,
1.0187816540094903,
-2.530890710602246,
-1.6046416850441676,
-0.4651483719733302,
-0.4952254087173721,
0.7746763768735953]
response = endpoint.predict([test_mpg])
print('API response: ', response)
print('Predicted MPG: ', response.predictions[0][0])
Ví dụ này đã có các giá trị được chuẩn hoá, đây là định dạng mà mô hình của chúng tôi mong đợi.
Chạy ô này và bạn sẽ thấy kết quả dự đoán là khoảng 16 dặm/gallon.
🎉 Xin chúc mừng! 🎉
Bạn đã tìm hiểu cách sử dụng Vertex AI để:
- Huấn luyện một mô hình bằng cách cung cấp mã huấn luyện trong một vùng chứa tuỳ chỉnh. Bạn đã sử dụng một mô hình TensorFlow trong ví dụ này, nhưng bạn có thể huấn luyện một mô hình được xây dựng bằng bất kỳ khung nào bằng cách sử dụng các vùng chứa tuỳ chỉnh.
- Triển khai một mô hình TensorFlow bằng vùng chứa được tạo sẵn trong quy trình tương tự mà bạn đã dùng để huấn luyện.
- Tạo một điểm cuối mô hình và tạo một dự đoán.
Để tìm hiểu thêm về các phần khác nhau của Vertex, hãy xem tài liệu.
7. Dọn dẹp
Nếu muốn tiếp tục sử dụng sổ tay bạn đã tạo trong phòng thí nghiệm này, bạn nên tắt sổ tay khi không sử dụng. Trong giao diện người dùng Workbench của Cloud Console, hãy chọn sổ tay rồi chọn Dừng.
Nếu bạn muốn xoá toàn bộ sổ tay, hãy nhấp vào nút Xoá ở trên cùng bên phải.
Để xoá điểm cuối mà bạn đã triển khai, hãy chuyển đến mục Điểm cuối trong bảng điều khiển Vertex AI, nhấp vào điểm cuối bạn đã tạo, rồi chọn Huỷ triển khai mô hình khỏi điểm cuối:
Để xoá Thùng lưu trữ, hãy sử dụng trình đơn Điều hướng trong Cloud Console, duyệt tìm Bộ nhớ, chọn thùng của bạn rồi nhấp vào Xoá:
