1. Tổng quan
Trong lớp học này, bạn sẽ sử dụng Vertex AI để huấn luyện và phân phát mô hình TensorFlow bằng mã trong vùng chứa tuỳ chỉnh.
Mặc dù chúng ta đang sử dụng TensorFlow cho mã mô hình tại đây, nhưng bạn có thể dễ dàng thay thế TensorFlow 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 công việc huấn luyện mô hình tuỳ chỉnh cho Vertex AI
- Triển khai mô hình đã huấn luyện cho một điểm cuối và sử dụng điểm cuối đó để nhận kết quả dự đoán
Tổng chi phí để chạy lớp học này trên Google Cloud là khoảng 1 USD.
2. Giới thiệu về Vertex AI
Lớp học này sử dụng sản phẩm AI mới nhất có trên Google Cloud. Vertex AI tích hợp các dịch vụ học máy trên Google Cloud vào một trải nghiệm phát triển liền mạch. Trước đây, bạn có thể truy cập vào các mô hình được huấn luyện bằng AutoML và mô hình tuỳ chỉnh thông qua các dịch vụ riêng biệt. Sản phẩm mới 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 xem trang hỗ trợ.
Vertex AI bao gồm nhiều sản phẩm để hỗ trợ quy trình làm việc toàn diện về máy học. 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 dưới đây: Đà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 dự án, hãy làm theo hướng dẫn tại đây.
Bước 1: Bật API Compute Engine
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 API Vertex AI
Chuyển đến mục Vertex AI trong Cloud Console rồi nhấp vào Bật API Vertex AI.
Bước 3: Bật API Registry Container
Chuyển đến Sổ đăng ký vùng chứa và chọn Bật nếu bạn chưa chọn. Bạn sẽ 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 thực thể Vertex AI Workbench
Trong phần Vertex AI của Cloud Console, hãy nhấp vào Workbench (Bảng điều khiển):
Tại đó, trong phần Sổ tay do người dùng quản lý, hãy nhấp vào 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 chế độ mặc định rồi nhấp vào Tạo.
Mô hình mà chúng tôi 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 từ các 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 mức tiết kiệm nhiên liệu của một chiếc xe.
4. Đóng gói 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 vào 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 tạo bằng bất kỳ khung nào.
Để bắt đầu, trên trình đơn Trình chạy, hãy mở cửa sổ Dòng lệnh trong thực thể máy tính xách tay:
Tạo một thư mục mới có tên là mpg và cd vào thư mục đó:
mkdir mpg
cd mpg
Bước 1: Tạo Dockerfile
Bước đầu tiên trong việc đóng gói mã 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ả 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 Terminal, hãy tạo một Dockerfile trống:
touch Dockerfile
Mở Dockerfile và sao chép nội dung sau vào tệp đó:
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"]
Tệp Dockerfile này sử dụng hình ảnh Docker Deep Learning Container TensorFlow Enterprise 2.3. Vùng chứa học sâu 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. Phiên bản chúng tôi đang sử dụng gồm có TF Enterprise 2.3, Gấu trúc, Scikit-learn và các phiên bản khác. Sau khi tải hình ảnh đó xuống, Dockerfile này sẽ thiết lập điểm nhậ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 trên Cloud Storage
Trong công việc huấn luyện, chúng ta sẽ xuất mô hình TensorFlow đã huấn luyện sang một Bộ chứa trên Cloud Storage. Vertex sẽ sử dụng tệp này để đọc các thành phần mô hình đã xuất và triển khai mô hình. Trên Terminal, hãy chạy đoạn mã sau để xác định biến env cho dự án, nhớ thay thế your-cloud-project bằng mã nhận dạng của dự án:
PROJECT_ID='your-cloud-project'
Tiếp theo, chạy dòng sau trong dòng lệnh để tạo một bộ chứa mới trong dự án của bạn. Cờ -l (vị trí) rất quan trọng vì cờ này cần phải nằm trong cùng khu vực mà bạn triển khai điểm cuối của mô hình ở phần sau của 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
Trên Terminal, hãy chạy lệnh sau để tạo thư mục cho mã huấn luyện và tệp Python mà chúng ta sẽ thêm mã vào:
mkdir trainer
touch trainer/train.py
Bây giờ, bạn sẽ có tệp 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 và 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).
Ở đầu tệp, hãy cập nhật biến BUCKET bằng tên của Bộ chứa bộ nhớ 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ử cục bộ vùng chứa
Trên 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 thực thể sổ tay để đảm bảo vùng chứa đó hoạt động chính xác:
docker run $IMAGE_URI
Mô hình sẽ kết thúc 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 có thể thay đổi). Khi bạn chạy xong vùng chứa trên máy, hãy đẩy vùng chứa đó vào Google Container Registry:
docker push $IMAGE_URI
Sau khi đẩy vùng chứa vào Container Registry, chúng ta đã sẵn sàng bắt đầu một công việc huấn luyện mô hình tuỳ chỉnh.
5. Chạy công việc huấn luyện trên Vertex AI
Vertex AI cung cấp cho bạn hai 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ề máy học.
- Huấn luyện tuỳ chỉnh: Chạy các ứng dụng huấn luyện tuỳ chỉnh trên đám mây bằng một trong các vùng chứa tạo sẵn của Google Cloud hoặc sử dụng vùng chứa của riêng bạn.
Trong lớp học này, chúng ta sẽ sử dụng tính nă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 (Đỉnh) của bảng điều khiển Google 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 thông số cho công việc đào tạo và mô hình đã triển khai:
- 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 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 mà bạn muốn gọi 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 Hình ảnh vùng chứa, hãy nhấp vào Duyệt qua và 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 tham số siêu dữ liệu trong hướng dẫn này, vì vậy, hãy bỏ đánh dấu hộp Enable hyperparameter tuning (Bật tính năng điều chỉnh tham số siêu dữ liệu) rồi nhấp vào Continue (Tiếp tục).
Trong phần Tính toán và định giá, hãy giữ nguyên khu vực đã chọn rồi chọn n1-standard-4 làm loại máy của bạn:
Để trống các trường trình 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, 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 tạo sẵn rồi chọn TensorFlow 2.6.
Giữ nguyên chế độ cài đặt mặc định cho vùng chứa tạo sẵn. Trong phần Thư mục mô hình, hãy nhập bộ chứa GCS của bạn bằng thư mục con mpg. Đây là đường dẫn trong tập lệnh huấn luyện mô hình mà bạn xuất mô hình đã huấn luyện:
Vertex sẽ tìm ở vị trí này khi triển khai mô hình của bạn. Giờ thì bạn đã sẵn sàng để bắt đầu đào tạo! 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 trên bảng điều khiển, bạn sẽ thấy nội dung như sau:
6. Triển khai điểm cuối mô hình
Khi thiết lập công việc huấn luyện, chúng ta đã chỉ định vị trí Vertex AI sẽ tìm kiếm các thành phần mô hình đã xuất. Trong quy trình huấn luyện, 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ô hình, bạn sẽ sẵn sàng triển khai đến đ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 này.
Ở 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ể dùng nền tảng này để nhận thông tin dự đoán về mô hình của mình thông qua Vertex AI API.
Bước 1: Triển khai điểm cuối
Khi công việc huấn luyện hoàn tất, bạn sẽ thấy một mô hình có tên mpg (hoặc bất kỳ tên nào bạn đặt) trong phần Mô hình của bảng điều khiển:
Khi công việc huấn luyện của bạn chạy, Vertex đã 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 trên mỗi mô hình. Nhấp vào mô hình rồi nhấp vào Deploy to Endpoint (Triển khai cho đ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 Chuẩn cho quyền Truy cập, rồi nhấp vào Tiếp tục.
Giữ nguyên Traffic split (Phân chia lưu lượng truy cập) ở mức 100 và nhập 1 cho Minimum number of compute nodes (Số nút tính toán tối thiểu). Trong mục 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). Giữ nguyên các chế độ 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.
Quá trình 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:
Bước 2: Nhận kết quả dự đoán trên mô hình đã triển khai
Chúng ta sẽ nhận được thông tin dự đoán về mô hình đã huấn luyện từ một sổ tay Python, bằng cách sử dụng API Vertex Python. Quay lại thực thể sổ tay và tạo một sổ tay Python 3 từ Trình chạy:
Trong sổ tay, hãy chạy mã sau trong một ô để cài đặt SDK Vertex AI:
!pip3 install google-cloud-aiplatform --upgrade --user
Sau đó, hãy thêm một ô trong sổ tay để nhập SDK và tạo một tệp 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 cần thay thế hai 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 mã số dự án bằng cách chuyển đến trang tổng quan dự án rồi nhận giá trị Số dự án.
Bạn có thể tìm thấy mã thiết bị đầu cuối trong mục 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ị chuẩn hoá, đây là định dạng mà mô hình của chúng ta đang mong đợi.
Chạy ô này và bạn sẽ thấy kết quả dự đoán 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ô hình bằng cách cung cấp mã huấn luyện trong vùng chứa tuỳ chỉnh. Bạn đã sử dụng mô hình TensorFlow trong ví dụ này, nhưng bạn có thể huấn luyện mô hình được tạo bằng bất kỳ khung nào bằng cách sử dụng vùng chứa tuỳ chỉnh.
- Triển khai mô hình TensorFlow bằng cách sử dụng vùng chứa tạo sẵn trong cùng một quy trình công việc mà bạn đã sử dụng để huấn luyện.
- Tạo điểm cuối mô hình và tạo 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 này.
7. Dọn dẹp
Nếu muốn tiếp tục sử dụng sổ tay mà bạn đã tạo trong lớp học 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 trong Cloud Console, hãy chọn sổ tay rồi chọn Stop (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 phần Điểm cuối của bảng điều khiển Vertex AI, nhấp vào điểm cuối mà bạn đã tạo, rồi chọn Huỷ triển khai mô hình khỏi điểm cuối:
Để xoá Bộ nhớ, hãy sử dụng trình đơn Điều hướng trong Cloud Console, chuyển đến Bộ nhớ, chọn bộ nhớ của bạn rồi nhấp vào Xoá:
