1. ภาพรวม
ในห้องทดลองนี้ คุณจะได้เรียนรู้วิธีใช้ Vertex AI ซึ่งเป็นแพลตฟอร์ม ML ที่มีการจัดการที่เพิ่งประกาศใหม่ของ Google Cloud เพื่อสร้างเวิร์กโฟลว์ ML แบบครบวงจร คุณจะได้เรียนรู้วิธีเปลี่ยนจากข้อมูลดิบไปเป็นโมเดลที่ทำให้ใช้งานได้ และจะออกจากเวิร์กช็อปนี้ให้พร้อมสำหรับการพัฒนาและสร้างโปรเจ็กต์ ML ของคุณเองด้วย Vertex AI ในห้องทดลองนี้ เราใช้ Cloud Shell ในการสร้างอิมเมจ Docker ที่กำหนดเองเพื่อแสดงคอนเทนเนอร์ที่กำหนดเองสำหรับการฝึกด้วย Vertex AI
ขณะที่เรากำลังใช้ TensorFlow สำหรับโค้ดโมเดลที่นี่อยู่ คุณสามารถแทนที่ด้วยเฟรมเวิร์กอื่นได้อย่างง่ายดาย
สิ่งที่ได้เรียนรู้
โดยคุณจะได้เรียนรู้วิธีต่อไปนี้
- สร้างคอนเทนเนอร์โค้ดการฝึกโมเดลโดยใช้ Cloud Shell
- ส่งงานการฝึกโมเดลที่กำหนดเองไปยัง Vertex AI
- ทำให้โมเดลที่ผ่านการฝึกใช้งานได้ที่ปลายทาง แล้วใช้ปลายทางดังกล่าวเพื่อรับการคาดการณ์
ค่าใช้จ่ายรวมในการเรียกใช้ห้องทดลองนี้บน Google Cloud อยู่ที่ประมาณ $2
2. ข้อมูลเบื้องต้นเกี่ยวกับ Vertex AI
ห้องทดลองนี้ใช้ข้อเสนอผลิตภัณฑ์ AI ใหม่ล่าสุดที่มีให้บริการใน Google Cloud Vertex AI ผสานรวมข้อเสนอ ML ใน Google Cloud เข้ากับประสบการณ์การพัฒนาที่ราบรื่น ก่อนหน้านี้โมเดลที่ฝึกด้วย AutoML และโมเดลที่กำหนดเองจะเข้าถึงได้ผ่านบริการแยกต่างหาก ข้อเสนอใหม่จะรวมทั้ง 2 อย่างไว้ใน API เดียว รวมทั้งผลิตภัณฑ์ใหม่อื่นๆ นอกจากนี้ คุณยังย้ายข้อมูลโปรเจ็กต์ที่มีอยู่ไปยัง Vertex AI ได้ด้วย หากมีความคิดเห็น โปรดดูหน้าการสนับสนุน
Vertex มีเครื่องมือต่างๆ มากมายที่จะช่วยคุณในแต่ละขั้นตอนของเวิร์กโฟลว์ ML ดังที่คุณเห็นจากแผนภาพด้านล่าง เราจะมุ่งเน้นที่การใช้การฝึกและการคาดการณ์ Vertex ที่ไฮไลต์ด้านล่าง
3. ตั้งค่าสภาพแวดล้อมของคุณ
การตั้งค่าสภาพแวดล้อมตามเวลาที่สะดวก
ลงชื่อเข้าใช้ Cloud Console และสร้างโปรเจ็กต์ใหม่หรือใช้โปรเจ็กต์ที่มีอยู่ซ้ำ (หากยังไม่มีบัญชี Gmail หรือ Google Workspace คุณต้องสร้างบัญชี)
โปรดจดจำรหัสโปรเจ็กต์ ซึ่งเป็นชื่อที่ไม่ซ้ำกันในโปรเจ็กต์ Google Cloud ทั้งหมด (ชื่อด้านบนมีคนใช้แล้ว และจะใช้ไม่ได้ ขออภัย)
ถัดไป คุณจะต้องเปิดใช้การเรียกเก็บเงินใน Cloud Console เพื่อใช้ทรัพยากร Google Cloud
การใช้งาน Codelab นี้น่าจะไม่มีค่าใช้จ่ายใดๆ หากมี ตรวจสอบว่าคุณได้ทำตามวิธีการใน "การล้างข้อมูล" ซึ่งจะแนะนำคุณเกี่ยวกับวิธีปิดทรัพยากรเพื่อไม่ให้มีการเรียกเก็บเงินนอกเหนือจากบทแนะนำนี้ ผู้ใช้ใหม่ของ Google Cloud จะมีสิทธิ์เข้าร่วมโปรแกรมทดลองใช้ฟรี$300 USD
ขั้นตอนที่ 1: เริ่มต้น Cloud Shell
ในห้องทดลองนี้ คุณจะได้ทำงานในเซสชัน Cloud Shell ซึ่งเป็นล่ามคำสั่งที่เครื่องเสมือนทำงานในระบบคลาวด์ของ Google คุณสามารถเรียกใช้ส่วนนี้ในคอมพิวเตอร์ของคุณเองได้ง่ายๆ แต่การใช้ Cloud Shell จะทำให้ทุกคนเข้าถึงประสบการณ์ที่ทำซ้ำได้ในสภาพแวดล้อมที่สอดคล้องกัน หลังจากการทดลองแล้ว คุณสามารถลองดำเนินการในส่วนนี้อีกครั้งในคอมพิวเตอร์ของคุณเอง
เปิดใช้งาน Cloud Shell
จากด้านขวาบนของ Cloud Console ให้คลิกปุ่มด้านล่างเพื่อเปิดใช้งาน Cloud Shell
หากคุณไม่เคยเริ่มต้นใช้งาน Cloud Shell มาก่อน คุณจะเห็นหน้าจอตรงกลาง (ครึ่งหน้าล่าง) ซึ่งอธิบายว่านี่คืออะไร หากเป็นเช่นนั้น ให้คลิกดำเนินการต่อ (คุณจะไม่เห็นการดำเนินการนี้อีก) หน้าจอแบบครั้งเดียวมีลักษณะดังนี้
การจัดสรรและเชื่อมต่อกับ Cloud Shell ใช้เวลาเพียงไม่กี่นาที
เครื่องเสมือนนี้เต็มไปด้วยเครื่องมือการพัฒนาทั้งหมดที่คุณต้องการ โดยมีไดเรกทอรีหลักขนาด 5 GB ที่ทำงานอย่างต่อเนื่องใน Google Cloud ซึ่งจะช่วยเพิ่มประสิทธิภาพของเครือข่ายและการตรวจสอบสิทธิ์ได้อย่างมาก งานส่วนใหญ่ใน Codelab นี้สามารถทำได้โดยใช้เบราว์เซอร์หรือ Chromebook เท่านั้น
เมื่อเชื่อมต่อกับ Cloud Shell คุณควรเห็นว่าได้รับการตรวจสอบสิทธิ์แล้ว และโปรเจ็กต์ได้รับการตั้งค่าเป็นรหัสโปรเจ็กต์แล้ว
เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell เพื่อยืนยันว่าคุณได้รับการตรวจสอบสิทธิ์แล้ว
gcloud auth list
เอาต์พุตจากคำสั่ง
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell เพื่อยืนยันว่าคำสั่ง gcloud รู้เกี่ยวกับโปรเจ็กต์ของคุณ
gcloud config list project
เอาต์พุตจากคำสั่ง
[core] project = <PROJECT_ID>
หากไม่ใช่ ให้ตั้งคำสั่งด้วยคำสั่งนี้
gcloud config set project <PROJECT_ID>
เอาต์พุตจากคำสั่ง
Updated property [core/project].
Cloud Shell มีตัวแปรสภาพแวดล้อมบางรายการ รวมถึง GOOGLE_CLOUD_PROJECT ที่มีชื่อโปรเจ็กต์ Cloud ปัจจุบันของเรา เราจะใช้สิ่งนี้ในที่ต่างๆ ทั่วทั้งห้องทดลองนี้ ซึ่งสามารถดูได้โดยการเรียกใช้:
echo $GOOGLE_CLOUD_PROJECT
ขั้นตอนที่ 2: เปิดใช้ API
ในขั้นตอนต่อๆ มา คุณจะเห็นว่าต้องใช้บริการเหล่านี้ (และเพราะเหตุใด) แต่ตอนนี้ให้เรียกใช้คำสั่งนี้เพื่อให้สิทธิ์เข้าถึงบริการ Compute Engine, Container Registry และ Vertex AI
gcloud services enable compute.googleapis.com \
containerregistry.googleapis.com \
aiplatform.googleapis.com
ซึ่งจะสร้างข้อความที่ประสบความสำเร็จในลักษณะเดียวกับข้อความต่อไปนี้
Operation "operations/acf.cc11852d-40af-47ad-9d59-477a12847c9e" finished successfully.
ขั้นตอนที่ 3: สร้างที่เก็บข้อมูล Cloud Storage
เราต้องใช้ที่เก็บข้อมูลของพื้นที่เก็บข้อมูลเพื่อจัดเก็บชิ้นงานโมเดลที่บันทึกไว้เพื่อเรียกใช้งานการฝึกบน Vertex AI เรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัล Cloud Shell เพื่อสร้างที่เก็บข้อมูล
BUCKET_NAME=gs://$GOOGLE_CLOUD_PROJECT-bucket
gsutil mb -l us-central1 $BUCKET_NAME
ขั้นตอนที่ 4: ชื่อแทน Python 3
โค้ดในห้องทดลองนี้ใช้ Python 3 เพื่อให้แน่ใจว่าคุณใช้ Python 3 เมื่อเรียกใช้สคริปต์ที่คุณจะสร้างใน Lab นี้ ให้สร้างชื่อแทนโดยเรียกใช้รายการต่อไปนี้ใน Cloud Shell
alias python=python3
โมเดลที่เราจะฝึกและให้บริการในห้องทดลองนี้สร้างขึ้นจากบทแนะนำนี้จากเอกสาร TensorFlow บทแนะนำใช้ชุดข้อมูล MPG อัตโนมัติจาก Kaggle เพื่อคาดการณ์ประสิทธิภาพการใช้เชื้อเพลิงของยานพาหนะ
4. สร้างคอนเทนเนอร์โค้ดการฝึก
เราจะส่งงานการฝึกนี้ไปยัง Vertex โดยวางโค้ดการฝึกของเราในคอนเทนเนอร์ Docker และพุชคอนเทนเนอร์นี้ไปยัง Google Container Registry เมื่อใช้แนวทางนี้ เราสามารถฝึกโมเดลที่สร้างด้วยเฟรมเวิร์กใดก็ได้
ขั้นตอนที่ 1: ตั้งค่าไฟล์
หากต้องการเริ่มต้น ให้เรียกใช้คำสั่งต่อไปนี้เพื่อสร้างไฟล์ที่จำเป็นสำหรับคอนเทนเนอร์ Docker จากเทอร์มินัลใน Cloud Shell
mkdir mpg
cd mpg
touch Dockerfile
mkdir trainer
touch trainer/train.py
ตอนนี้คุณควรมีไดเรกทอรี mpg/ ที่มีลักษณะดังนี้
+ Dockerfile
+ trainer/
+ train.py
เราจะใช้ตัวแก้ไขโค้ดในตัวของ Cloud Shell เพื่อดูและแก้ไขไฟล์เหล่านี้ คุณสลับไปมาระหว่างเครื่องมือแก้ไขและเทอร์มินัลได้โดยคลิกปุ่มบนแถบเมนูด้านขวาบนใน Cloud Shell ดังนี้
ขั้นตอนที่ 2: สร้าง Dockerfile
ในการสร้างโค้ดของเราให้เป็นคอนเทนเนอร์ เราจะสร้าง Dockerfile ก่อน ใน Dockerfile เราจะรวมคำสั่งทั้งหมดที่จำเป็นต่อการเรียกใช้อิมเมจ ซึ่งจะติดตั้งไลบรารีทั้งหมดที่เราใช้ และตั้งค่าจุดแรกเข้าสำหรับโค้ดการฝึกอบรมของเรา
จากตัวแก้ไขไฟล์ Cloud Shell ให้เปิดไดเรกทอรี mpg/ แล้วดับเบิลคลิกเพื่อเปิด Dockerfile:
จากนั้นคัดลอกข้อมูลต่อไปนี้ลงในไฟล์นี้
FROM gcr.io/deeplearning-platform-release/tf2-cpu.2-3
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 นี้ใช้อิมเมจ Docker ของ Deep Learning TensorFlow Enterprise 2.3 คอนเทนเนอร์การเรียนรู้เชิงลึกบน Google Cloud มาพร้อมกับเฟรมเวิร์ก ML และวิทยาศาสตร์ข้อมูลทั่วไปมากมายที่ติดตั้งไว้ล่วงหน้า สิ่งที่เราใช้อยู่มี TF Enterprise 2.3, Pandas, Scikit-learn และอื่นๆ หลังจากดาวน์โหลดอิมเมจดังกล่าวแล้ว Dockerfile นี้จะตั้งค่าจุดแรกเข้าสำหรับโค้ดการฝึกของเรา ซึ่งเราจะเพิ่มลงในขั้นตอนถัดไป
ขั้นตอนที่ 3: เพิ่มโค้ดการฝึกโมเดล
จากตัวแก้ไข Cloud Shell ให้เปิดไฟล์ train.py และคัดลอกโค้ดด้านล่าง (ซึ่งปรับเปลี่ยนมาจากบทแนะนำในเอกสาร TensorFlow)
# This will be replaced with your bucket name after running the `sed` command in the tutorial
BUCKET = "BUCKET_NAME"
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.
"""
"""Import it using pandas"""
dataset_path = "https://storage.googleapis.com/io-vertex-codelab/auto-mpg.csv"
dataset = pd.read_csv(dataset_path, na_values = "?")
dataset.tail()
"""### 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')
เมื่อคัดลอกรหัสด้านบนลงในไฟล์ mpg/trainer/train.py แล้ว ให้กลับไปที่เทอร์มินัลใน Cloud Shell และเรียกใช้คำสั่งต่อไปนี้เพื่อเพิ่มชื่อที่เก็บข้อมูลของคุณเองลงในไฟล์
sed -i "s|BUCKET_NAME|$BUCKET_NAME|g" trainer/train.py
ขั้นตอนที่ 4: สร้างและทดสอบคอนเทนเนอร์ในเครื่อง
จากเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้เพื่อกำหนดตัวแปรด้วย URI ของอิมเมจคอนเทนเนอร์ใน Google Container Registry
IMAGE_URI="gcr.io/$GOOGLE_CLOUD_PROJECT/mpg:v1"
จากนั้นสร้างคอนเทนเนอร์โดยเรียกใช้คำสั่งต่อไปนี้จากรูทของไดเรกทอรี mpg
docker build ./ -t $IMAGE_URI
เมื่อสร้างคอนเทนเนอร์แล้ว ให้พุชไปยัง Google Container Registry ดังนี้
docker push $IMAGE_URI
เพื่อยืนยันว่ามีการพุชอิมเมจของคุณไปยัง Container Registry คุณควรเห็นสิ่งเหล่านี้เมื่อไปที่ส่วน Container Registry ของคอนโซล
เมื่อคอนเทนเนอร์ของเราพุชไปยัง Container Registry เราพร้อมเริ่มต้นงานการฝึกโมเดลที่กำหนดเองแล้ว
5. เรียกใช้งานการฝึกใน Vertex AI
Vertex มี 2 ตัวเลือกสำหรับการฝึกโมเดล ได้แก่
- AutoML: ฝึกโมเดลที่มีคุณภาพสูงอย่างง่ายดายโดยไม่ต้องมีความเชี่ยวชาญด้าน ML
- การฝึกที่กำหนดเอง: เรียกใช้แอปพลิเคชันการฝึกที่กำหนดเองในระบบคลาวด์โดยใช้คอนเทนเนอร์สำเร็จรูปของ Google Cloud หรือใช้คอนเทนเนอร์ของคุณเอง
ในห้องทดลองนี้ เราใช้การฝึกที่กำหนดเองผ่านคอนเทนเนอร์ที่กำหนดเองของเราใน Google Container Registry เริ่มต้นด้วยการไปที่ส่วนการฝึกในส่วน Vertex ของ Cloud Console โดยทำดังนี้
ขั้นตอนที่ 1: เริ่มต้นงานการฝึก
คลิกสร้างเพื่อป้อนพารามิเตอร์สำหรับงานการฝึกและโมเดลที่ทำให้ใช้งานได้แล้ว
- ในส่วนชุดข้อมูล ให้เลือกไม่มีชุดข้อมูลที่มีการจัดการ
- จากนั้นเลือกการฝึกที่กำหนดเอง (ขั้นสูง) เป็นวิธีการฝึก แล้วคลิกต่อไป
- ป้อน
mpg(หรืออะไรก็ตามที่ต้องการเรียกโมเดลของคุณ) สำหรับชื่อโมเดล - คลิกต่อไป
ในขั้นตอนการตั้งค่าคอนเทนเนอร์ ให้เลือกคอนเทนเนอร์ที่กำหนดเอง ดังนี้
ในช่องแรก (อิมเมจคอนเทนเนอร์) ให้คลิกเรียกดู และค้นหาคอนเทนเนอร์ที่คุณเพิ่งพุชไปยัง Container Registry ซึ่งควรมีหน้าตาเช่นนี้
เว้นช่องที่เหลือว่างไว้และคลิกดำเนินการต่อ
เราจะไม่ใช้การปรับแต่งไฮเปอร์พารามิเตอร์ในบทแนะนำนี้ ดังนั้นให้ปล่อยช่อง "เปิดใช้การปรับแต่งไฮเปอร์พารามิเตอร์" ให้ไม่เลือก แล้วคลิกต่อไป
ในการประมวลผลและการกำหนดราคา ให้ปล่อยภูมิภาคที่เลือกไว้ตามเดิมและเลือก n1-standard-4 เป็นประเภทเครื่อง:
เนื่องจากโมเดลในการสาธิตนี้ฝึกได้อย่างรวดเร็ว เราจึงใช้ประเภทเครื่องที่เล็กกว่า
ในขั้นตอนคอนเทนเนอร์การคาดการณ์ ให้เลือกไม่มีคอนเทนเนอร์การคาดการณ์ ดังนี้
6. ทำให้ปลายทางของโมเดลใช้งานได้
ในขั้นตอนนี้ เราจะสร้างปลายทางสำหรับโมเดลที่ผ่านการฝึก เราใช้ข้อมูลนี้เพื่อรับการคาดการณ์ในโมเดลของเราผ่าน Vertex AI API ได้ เราได้สร้างเวอร์ชันของชิ้นงานโมเดลที่ส่งออกแล้วให้ใช้ได้ในที่เก็บข้อมูล GCS สาธารณะ
การมีทีม 1 ทีมหรือบุคคลหนึ่งให้รับผิดชอบการสร้างโมเดลถือเป็นเรื่องปกติในองค์กร และมีอีกทีมหนึ่งที่ทำหน้าที่ทำให้โมเดลนั้นใช้งานได้ ขั้นตอนที่เราจะกล่าวถึงที่นี่จะแสดงวิธีนำโมเดลที่ได้รับการฝึกมาแล้วและทำให้ใช้งานได้สำหรับการคาดการณ์
ในที่นี้เราจะใช้ Vertex AI SDK เพื่อสร้างโมเดล ทำให้โมเดลใช้งานได้กับปลายทาง และรับการคาดการณ์
ขั้นตอนที่ 1: ติดตั้ง Vertex SDK
จากเทอร์มินัล Cloud Shell ให้เรียกใช้คำสั่งต่อไปนี้เพื่อติดตั้ง Vertex AI SDK
pip3 install google-cloud-aiplatform --upgrade --user
เราใช้ SDK นี้เพื่อโต้ตอบกับ Vertex ต่างๆ ได้
ขั้นตอนที่ 2: สร้างโมเดลและทำให้ปลายทางใช้งานได้
ต่อไป เราจะสร้างไฟล์ Python และใช้ SDK เพื่อสร้างทรัพยากรโมเดลและทำให้ใช้งานได้ที่ปลายทาง จากตัวแก้ไขไฟล์ใน Cloud Shell ให้เลือกไฟล์ แล้วเลือกไฟล์ใหม่
ตั้งชื่อไฟล์เป็น deploy.py เปิดไฟล์นี้ในตัวแก้ไขและคัดลอกโค้ดต่อไปนี้
from google.cloud import aiplatform
# Create a model resource from public model assets
model = aiplatform.Model.upload(
display_name="mpg-imported",
artifact_uri="gs://io-vertex-codelab/mpg-model/",
serving_container_image_uri="gcr.io/cloud-aiplatform/prediction/tf2-cpu.2-3:latest"
)
# Deploy the above model to an endpoint
endpoint = model.deploy(
machine_type="n1-standard-4"
)
จากนั้น กลับไปที่เทอร์มินัลใน Cloud Shell, cd กลับไปที่ไดเรกทอรีราก และเรียกใช้สคริปต์ Python ที่คุณเพิ่งสร้าง
cd ..
python3 deploy.py | tee deploy-output.txt
คุณจะเห็นการอัปเดตบันทึกลงในเทอร์มินัลเมื่อมีการสร้างทรัพยากร การดำเนินการนี้จะใช้เวลา 10-15 นาที ไปที่ส่วนโมเดลของคอนโซลใน Vertex AI เพื่อตรวจสอบว่าจะทำงานได้อย่างถูกต้อง
คลิก mgp-imported จากนั้นคุณควรเห็นปลายทางของโมเดลที่กำลังสร้าง
ในเทอร์มินัล Cloud Shell คุณจะเห็นบันทึกต่อไปนี้เมื่อการทำให้ปลายทางใช้งานได้เสร็จสมบูรณ์แล้ว
Endpoint model deployed. Resource name: projects/your-project-id/locations/us-central1/endpoints/your-endpoint-id
คุณจะใช้ข้อมูลนี้ในขั้นตอนถัดไปเพื่อรับการคาดการณ์เกี่ยวกับระบบการทำงานของเอ็นโดพินที่ทำให้ใช้งานได้
ขั้นตอนที่ 3: รับการคาดการณ์ในปลายทางที่ทำให้ใช้งานได้
ในเครื่องมือแก้ไข Cloud Shell ให้สร้างไฟล์ใหม่ชื่อ predict.py:
เปิด predict.py แล้ววางโค้ดต่อไปนี้ลงในไฟล์
from google.cloud import aiplatform
endpoint = aiplatform.Endpoint(
endpoint_name="ENDPOINT_STRING"
)
# A test example we'll send to our model for prediction
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])
จากนั้น ให้กลับไปที่เทอร์มินัล แล้วป้อนคำสั่งต่อไปนี้เพื่อแทนที่ ENDPOINT_STRING ในไฟล์การคาดการณ์ด้วยปลายทางของคุณเอง
ENDPOINT=$(cat deploy-output.txt | sed -nre 's:.*Resource name\: (.*):\1:p' | tail -1)
sed -i "s|ENDPOINT_STRING|$ENDPOINT|g" predict.py
ตอนนี้ก็ถึงเวลาเรียกใช้ไฟล์ predict.py เพื่อรับการคาดการณ์จากปลายทางโมเดลที่ทำให้ใช้งานได้แล้วของเรา
python3 predict.py
คุณควรจะเห็นการตอบกลับของ API ที่บันทึกไว้พร้อมกับการประหยัดเชื้อเพลิงที่คาดการณ์ไว้สำหรับการคาดการณ์การทดสอบของเรา
🎉 ยินดีด้วย 🎉
คุณได้เรียนรู้วิธีใช้ Vertex AI เพื่อทำสิ่งต่อไปนี้แล้ว
- ฝึกโมเดลด้วยการระบุโค้ดการฝึกในคอนเทนเนอร์ที่กำหนดเอง คุณใช้โมเดล TensorFlow ในตัวอย่างนี้ แต่สามารถฝึกโมเดลที่สร้างด้วยเฟรมเวิร์กใดก็ได้โดยใช้คอนเทนเนอร์ที่กำหนดเอง
- ทำให้โมเดล TensorFlow ใช้งานได้โดยใช้คอนเทนเนอร์ที่สร้างไว้ล่วงหน้าซึ่งเป็นส่วนหนึ่งของเวิร์กโฟลว์เดียวกับที่ใช้สำหรับการฝึก
- สร้างปลายทางของโมเดลและสร้างการคาดการณ์
ดูข้อมูลเพิ่มเติมเกี่ยวกับส่วนต่างๆ ของ Vertex AI ได้ในเอกสารประกอบ หากต้องการดูผลลัพธ์ของงานการฝึกที่คุณเริ่มในขั้นตอนที่ 5 ให้ไปที่ส่วนการฝึกของคอนโซล Vertex
7. ล้างข้อมูล
หากต้องการลบปลายทางที่คุณทำให้ใช้งานได้แล้ว ให้ไปที่ส่วนปลายทางของคอนโซล Vertex และคลิกไอคอนลบ:
หากต้องการลบที่เก็บข้อมูลของพื้นที่เก็บข้อมูล โดยใช้เมนูการนำทางใน Cloud Console จากนั้นเรียกดูพื้นที่เก็บข้อมูล เลือกที่เก็บข้อมูล แล้วคลิกลบ:
