Thông tin về lớp học lập trình này
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ô hình TensorFlow bằng mã trong một vùng chứa tuỳ chỉnh.
Trong khi chúng ta đang sử dụng TensorFlow cho mã mô hình ở đây, bạn có thể dễ dàng thay thế mã đó 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 thông tin dự đoán
Tổng chi phí để chạy phòng thí nghiệm này trên Google Cloud là khoảng 1 đô la.
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, các mô hình được huấn luyện bằng AutoML và mô hình tuỳ chỉnh có thể truy cập được thông qua các dịch vụ riêng biệt. Dịch vụ 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 một dự á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 Enable (Bật) nếu bạn chưa bật tính năng này. Bạn sẽ cần có gói này để tạo thực thể sổ tay.
Bước 2: Bật Vertex AI API
Chuyển đến phần Vertex AI trong Cloud Console rồi nhấp vào Bật Vertex AI API.
Bước 3: Bật Container Registry API
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ẽ dùng mã 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 mục Vertex AI trên Cloud Console, hãy nhấp vào Workbench:
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 tuỳ 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 lớp học lập trình này được xây dựng dựa trên hướng dẫn này trong tài liệu TensorFlow. Phần hướng dẫn này sử dụng tập dữ liệu Auto MPG của Kaggle để dự đoán mức tiết kiệm nhiên liệu của xe.
4. Đóng gói mã huấn luyện
Chúng tôi sẽ gửi công việc đào tạo này cho Vertex bằng cách đặt mã huấn luyện vào vùng chứa Docker và đẩy vùng chứa này vào Google Container Registry. Khi sử dụng phương pháp này, chúng ta có thể huấn luyện một mô hình xây dựng 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ể sổ tay của bạn:
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 một Dockerfile
Bước đầu tiên trong việc chứa mã là tạo 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 đây 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 của Deep Learning Container TensorFlow Enterprise 2.3. Các vùng chứa học sâu trên Google Cloud được cài đặt sẵn nhiều khung phổ biến của công nghệ học máy và khoa học dữ liệu. 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 Cloud Storage
Trong công việc đào tạo của mình, chúng tôi sẽ xuất mô hình TensorFlow đã qua huấn luyện sang một Bộ chứa trên đám mây. Vertex sẽ 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. Trên cửa sổ dòng lệnh, hãy chạy lệnh sau để xác định một biến env cho dự án của bạn, nhớ thay thế your-cloud-project bằng mã dự án của bạn:
PROJECT_ID='your-cloud-project'
Tiếp theo, hãy 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 phải nằm trong cùng một khu vực mà bạn triển khai điểm cuối của mô hình trong 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 các lệnh sau để tạo thư mục cho mã đào tạo 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 đoạn mã bên dưới (tệp này được điều chỉnh từ hướng dẫn trong các tài liệu về 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 Cửa sổ dòng lệnh, hãy xác định một biến có 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 của bạn để đảm bảo vùng chứa hoạt động đúng cách:
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 chính xác có thể khác nhau). Khi bạn hoàn tất việc chạy vùng chứa cục bộ, hãy đẩy vùng chứa đó vào Google Container Registry:
docker push $IMAGE_URI
Với vùng chứa của chúng tôi được đẩy vào Container Registry, giờ đây chúng tôi đã sẵn sàng bắt đầu 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
Với Vertex AI, bạn có 2 lựa chọn về các mô hình huấn luyện:
- AutoML: Đào tạo các mô hình chất lượng cao mà không cần nhiều công sức và kiến thức chuyên môn về máy học.
- Đào tạo 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ích hợp 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 của bảng điều khiển Cloud:
Bước 1: Bắt đầu công việc đào tạo
Nhấp vào Tạo để nhập các tham số cho công việc huấn luyện 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 thức 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 tôi sẽ không sử dụng tính năng tinh chỉnh siêu tham số trong hướng dẫn này, do đó, hãy bỏ chọn hộp Bật tính năng điều chỉnh siêu tham số và 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 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 các chế độ cài đặt mặc định cho vùng chứa tạo sẵn. Trong Thư mục mô hình, hãy nhập bộ chứa GCS của bạn chứa 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 dùng để xuất mô hình đã huấn luyện của mình:
Vertex sẽ tìm ở vị trí này khi triển khai mô hình của bạn. Bây giờ, bạn đã sẵn sàng học! Nhấp vào Bắt đầu đào tạo để bắt đầu công việc đào tạo. Trong phần Đào tạo 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 của mô hình
Khi thiết lập công việc đào tạo, chúng tôi đã chỉ định nơi Vertex AI sẽ tìm các tài sản mô hình đã xuất. Trong quy trình đào tạo 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 thành phầ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 mà bạn đặt tên) 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 đ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 chế độ Chuẩn để có quyền truy cập, rồi nhấp vào Tiếp tục.
Giữ nguyên phần Mức phân tách lưu lượng truy cập là 100 và nhập 1 cho 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). Chọn các tuỳ chọn 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 hoàn tất quá trình triển khai, bạn sẽ thấy như sau, cho thấy một điểm cuối được triển khai trong tài nguyên Mô hình:
Bước 2: Nhận thông tin dự đoán về mô hình đã triển khai
Chúng tôi sẽ nhận được thông tin dự đoán về mô hình đã qua huấn luyện từ sổ tay Python bằng API Vertex Python. Quay lại thực thể 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 lệnh 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 để nhập SDK và tạo tệp tham chiếu đến điểm cuối 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 mình. 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ã điểm cuối trong phần điểm 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.
Hãy 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ộ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 với 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ô hình TensorFlow bằng vùng chứa tạo sẵn trong quy trình công việc mà bạn dùng để huấn luyện.
- Tạo điểm cuối của mô hình và tạo thông tin 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 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 trong Cloud Console, hãy chọn sổ tay rồi chọn Stop (Dừng).
Nếu bạn muốn xoá hoàn toàn sổ tay, hãy nhấp vào nút Xoá ở trên cùng bên phải.
Để xoá điểm cuối bạn đã triển khai, hãy chuyển đến phần Endpoints (Đ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, sau đó chọn UnDeploy model from Endpoint (Huỷ triển khai mô hình từ điểm cuối):
Để xoá Bộ chứa Storage, hãy sử dụng trình đơn Điều hướng trong Cloud Console, duyệt đến Bộ nhớ, chọn bộ chứa rồi nhấp vào Xoá:
