1. ภาพรวม
ในห้องทดลองนี้ คุณจะได้ใช้ Vertex AI เพื่อฝึกและแสดงโมเดล TensorFlow โดยใช้โค้ดในคอนเทนเนอร์ที่กำหนดเอง
แม้ว่าเราจะใช้ TensorFlow สําหรับโค้ดโมเดลที่นี่ แต่คุณก็แทนที่ด้วยเฟรมเวิร์กอื่นได้ง่ายๆ
สิ่งที่คุณเรียนรู้
โดยคุณจะได้เรียนรู้วิธีต่อไปนี้
- สร้างและบรรจุโค้ดการฝึกโมเดลใน Vertex Workbench
- ส่งงานการฝึกโมเดลที่กำหนดเองไปยัง Vertex AI
- ทำให้โมเดลที่ฝึกแล้วใช้งานได้ในปลายทาง และใช้ปลายทางนั้นเพื่อรับการคาดการณ์
ค่าใช้จ่ายรวมในการเรียกใช้ห้องทดลองนี้บน Google Cloud อยู่ที่ประมาณ $1
2. ข้อมูลเบื้องต้นเกี่ยวกับ Vertex AI
ห้องทดลองนี้ใช้ข้อเสนอผลิตภัณฑ์ AI ใหม่ล่าสุดที่มีให้บริการใน Google Cloud Vertex AI ผสานรวมข้อเสนอ ML ทั่วทั้ง Google Cloud เข้าด้วยกันเพื่อมอบประสบการณ์การพัฒนาที่ราบรื่น ก่อนหน้านี้ โมเดลที่ฝึกด้วย AutoML และโมเดลที่กำหนดเองจะเข้าถึงได้ผ่านบริการแยกต่างหาก ข้อเสนอใหม่นี้รวมทั้ง 2 รายการไว้ใน API เดียว พร้อมกับผลิตภัณฑ์ใหม่อื่นๆ นอกจากนี้ คุณยังย้ายข้อมูลโปรเจ็กต์ที่มีอยู่ไปยัง Vertex AI ได้ด้วย หากมีความคิดเห็น โปรดดูหน้าการสนับสนุน
Vertex AI มีผลิตภัณฑ์หลายอย่างเพื่อรองรับเวิร์กโฟลว์ ML ตั้งแต่ต้นจนจบ ห้องทดลองนี้จะมุ่งเน้นที่ผลิตภัณฑ์ที่ไฮไลต์ไว้ด้านล่าง ได้แก่ การฝึกอบรม การคาดการณ์ และเวิร์กเบนค์
3. ตั้งค่าสภาพแวดล้อม
คุณจะต้องมีโปรเจ็กต์ Google Cloud Platform ที่เปิดใช้การเรียกเก็บเงินเพื่อเรียกใช้ Codelab นี้ หากต้องการสร้างโปรเจ็กต์ ให้ทำตามวิธีการที่นี่
ขั้นตอนที่ 1: เปิดใช้ Compute Engine API
ไปที่ Compute Engine แล้วเลือกเปิดใช้หากยังไม่ได้เปิดใช้ คุณต้องใช้ข้อมูลนี้เพื่อสร้างอินสแตนซ์สมุดบันทึก
ขั้นตอนที่ 2: เปิดใช้ Vertex AI API
ไปที่ส่วน Vertex AI ของ Cloud Console แล้วคลิกเปิดใช้ Vertex AI API
ขั้นตอนที่ 3: เปิดใช้ Container Registry API
ไปที่ Container Registry แล้วเลือกเปิดใช้ หากยังไม่ได้เปิดใช้ คุณจะใช้ข้อมูลนี้เพื่อสร้างคอนเทนเนอร์สำหรับงานการฝึกที่กำหนดเอง
ขั้นตอนที่ 4: สร้างอินสแตนซ์ Vertex AI Workbench
จากส่วน Vertex AI ของ Cloud Console ให้คลิก Workbench
จากตรงนั้น ให้คลิกโน้ตบุ๊กใหม่ภายในโน้ตบุ๊กที่ผู้ใช้จัดการ
จากนั้นเลือกประเภทอินสแตนซ์ TensorFlow Enterprise (ที่มี LTS) เวอร์ชันล่าสุดที่ไม่มี GPU
ใช้ตัวเลือกเริ่มต้น แล้วคลิกสร้าง
โมเดลที่เราจะฝึกและแสดงผลในห้องทดลองนี้สร้างขึ้นจากบทแนะนํานี้จากเอกสารประกอบของ TensorFlow บทแนะนำใช้ชุดข้อมูล MPG อัตโนมัติจาก Kaggle เพื่อคาดการณ์ประสิทธิภาพการใช้เชื้อเพลิงของยานพาหนะ
4. สร้างคอนเทนเนอร์โค้ดการฝึก
เราจะส่งงานการฝึกนี้ไปยัง Vertex โดยใส่โค้ดการฝึกในคอนเทนเนอร์ Docker และพุชคอนเทนเนอร์นี้ไปยัง Google Container Registry เมื่อใช้แนวทางนี้ เราสามารถฝึกโมเดลที่สร้างด้วยเฟรมเวิร์กใดก็ได้
ในการเริ่มต้น ให้เปิดหน้าต่างเทอร์มินัลในอินสแตนซ์โน้ตบุ๊กจากเมนู Launcher โดยทำดังนี้
สร้างไดเรกทอรีใหม่ชื่อ mpg แล้ว cd เข้าไป
mkdir mpg
cd mpg
ขั้นตอนที่ 1: สร้าง Dockerfile
ขั้นตอนแรกในการสร้างคอนเทนเนอร์โค้ดคือการสร้าง Dockerfile เราจะใส่คำสั่งทั้งหมดที่จำเป็นต่อการทำงานของอิมเมจไว้ใน Dockerfile การดำเนินการนี้จะติดตั้งไลบรารีทั้งหมดที่เราใช้อยู่และตั้งค่าจุดแรกเข้าสําหรับโค้ดการฝึก สร้าง Dockerfile เปล่าจากเทอร์มินัล โดยทำดังนี้
touch Dockerfile
เปิด Dockerfile และคัดลอกไฟล์ต่อไปนี้ลงในไฟล์
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 นี้ใช้อิมเมจ Docker ของ Deep Learning TensorFlow Enterprise 2.3 คอนเทนเนอร์การเรียนรู้เชิงลึกใน Google Cloud มาพร้อมกับเฟรมเวิร์ก ML และวิทยาการข้อมูลทั่วไปที่ติดตั้งไว้ล่วงหน้าหลายรายการ เครื่องมือที่เราใช้ ได้แก่ TF Enterprise 2.3, Pandas, Scikit-learn และอื่นๆ หลังจากดาวน์โหลดอิมเมจดังกล่าว Dockerfile นี้จะตั้งค่าจุดแรกเข้าสำหรับโค้ดการฝึกของเรา เรายังไม่ได้สร้างไฟล์เหล่านี้ ในขั้นตอนถัดไป เราจะเพิ่มโค้ดสำหรับการฝึกและส่งออกโมเดล
ขั้นตอนที่ 2: สร้างที่เก็บข้อมูล Cloud Storage
เราจะส่งออกโมเดล TensorFlow ที่ผ่านการฝึกไปยังที่เก็บข้อมูล Cloud Storage ในงานการฝึก Vertex จะใช้ค่านี้เพื่ออ่านเนื้อหาโมเดลที่ส่งออกของเราและทำให้โมเดลใช้งานได้ จากเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้เพื่อกำหนดตัวแปร env สำหรับโปรเจ็กต์ โดยอย่าลืมแทนที่ your-cloud-project ด้วยรหัสโปรเจ็กต์
PROJECT_ID='your-cloud-project'
จากนั้นเรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัลเพื่อสร้างที่เก็บข้อมูลใหม่ในโปรเจ็กต์ Flag -l (location) มีความสำคัญเนื่องจากต้องอยู่ในภูมิภาคเดียวกับที่คุณติดตั้งใช้งานปลายทางของโมเดลในบทแนะนำในภายหลัง
BUCKET_NAME="gs://${PROJECT_ID}-bucket"
gsutil mb -l us-central1 $BUCKET_NAME
ขั้นตอนที่ 3: เพิ่มโค้ดการฝึกโมเดล
จากเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้เพื่อสร้างไดเรกทอรีสําหรับโค้ดการฝึกและไฟล์ Python ที่เราจะใช้เพิ่มโค้ด
mkdir trainer
touch trainer/train.py
ตอนนี้คุณควรมีสิ่งต่อไปนี้ในไดเรกทอรี mpg/
+ Dockerfile
+ trainer/
+ train.py
ถัดไป ให้เปิดไฟล์ train.py ที่คุณเพิ่งสร้างและคัดลอกโค้ดด้านล่าง (ดัดแปลงมาจากบทแนะนำในเอกสารประกอบของ TensorFlow)
ที่ส่วนต้นของไฟล์ ให้อัปเดตตัวแปร BUCKET ด้วยชื่อของที่เก็บข้อมูลที่คุณสร้างขึ้นในขั้นตอนก่อนหน้า
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')
ขั้นตอนที่ 4: สร้างและทดสอบคอนเทนเนอร์ในเครื่อง
จากเทอร์มินัล ให้กําหนดตัวแปรด้วย URI ของอิมเมจคอนเทนเนอร์ใน Google Container Registry โดยทําดังนี้
IMAGE_URI="gcr.io/$PROJECT_ID/mpg:v1"
จากนั้นสร้างคอนเทนเนอร์โดยเรียกใช้คำสั่งต่อไปนี้จากรูทของไดเรกทอรี mpg
docker build ./ -t $IMAGE_URI
เรียกใช้คอนเทนเนอร์ภายในอินสแตนซ์โน้ตบุ๊กเพื่อให้แน่ใจว่าทำงานได้อย่างถูกต้อง โดยทำดังนี้
docker run $IMAGE_URI
โมเดลควรฝึกเสร็จภายใน 1-2 นาทีด้วยความแม่นยำในการทดสอบประมาณ 72% (ความแม่นยำที่แน่นอนอาจแตกต่างกันไป) เมื่อเรียกใช้คอนเทนเนอร์ในเครื่องเสร็จแล้ว ให้พุชคอนเทนเนอร์ไปยัง Google Container Registry โดยทำดังนี้
docker push $IMAGE_URI
เมื่อคอนเทนเนอร์ของเราพุชไปยัง Container Registry เราพร้อมเริ่มต้นงานการฝึกโมเดลที่กำหนดเองแล้ว
5. เรียกใช้งานการฝึกใน Vertex AI
Vertex AI มี 2 ตัวเลือกสำหรับการฝึกโมเดล ได้แก่
- AutoML: ฝึกโมเดลที่มีคุณภาพสูงอย่างง่ายดายโดยไม่ต้องมีความเชี่ยวชาญด้าน ML
- การฝึกที่กำหนดเอง: เรียกใช้แอปพลิเคชันการฝึกที่กำหนดเองในระบบคลาวด์โดยใช้คอนเทนเนอร์สำเร็จรูปของ Google Cloud หรือใช้คอนเทนเนอร์ของคุณเอง
ในแล็บนี้ เราใช้การฝึกอบรมที่กำหนดเองผ่านคอนเทนเนอร์ที่กำหนดเองของเราเองใน Google Container Registry ในการเริ่มต้น ให้ไปที่ส่วนโมเดลในส่วน Vertex ของคอนโซล Cloud
ขั้นตอนที่ 1: เริ่มงานการฝึก
คลิกสร้างเพื่อป้อนพารามิเตอร์สําหรับงานการฝึกและโมเดลที่ติดตั้งใช้งาน
- ในส่วนชุดข้อมูล ให้เลือกไม่มีชุดข้อมูลที่มีการจัดการ
- จากนั้นเลือกการฝึกแบบกำหนดเอง (ขั้นสูง) เป็นวิธีการฝึก แล้วคลิกต่อไป
- คลิกต่อไป
ในขั้นตอนถัดไป ให้ป้อน mpg (หรือชื่อใดก็ได้ที่ต้องการตั้งให้กับโมเดล) สำหรับชื่อโมเดล จากนั้นเลือกคอนเทนเนอร์ที่กำหนดเอง
ในช่องข้อความอิมเมจคอนเทนเนอร์ ให้คลิกเรียกดู แล้วค้นหาอิมเมจ Docker ที่คุณเพิ่งอัปโหลดไปยัง Container Registry เว้นช่องที่เหลือว่างไว้ แล้วคลิกต่อไป
เราจะไม่ใช้การปรับแต่งไฮเปอร์พารามิเตอร์ในบทแนะนํานี้ ดังนั้นให้ยกเลิกการเลือกช่องเปิดใช้การปรับแต่งไฮเปอร์พารามิเตอร์ แล้วคลิกต่อไป
ในการประมวลผลและราคา ให้ปล่อยภูมิภาคที่เลือกไว้ตามเดิมและเลือก n1-standard-4 เป็นประเภทเครื่อง
เว้นช่อง Accelerator ว่างไว้และเลือกดำเนินการต่อ เนื่องจากโมเดลในการสาธิตนี้ฝึกได้อย่างรวดเร็ว เราจึงใช้ประเภทเครื่องที่เล็กกว่า
ในส่วนคอนเทนเนอร์การคาดการณ์ ให้เลือกคอนเทนเนอร์ที่สร้างไว้ล่วงหน้า แล้วเลือก TensorFlow 2.6
คงการตั้งค่าเริ่มต้นสำหรับคอนเทนเนอร์ที่สร้างไว้ล่วงหน้าไว้ตามเดิม ภายใต้ไดเรกทอรีโมเดล ให้ป้อนที่เก็บข้อมูล GCS ที่มีไดเรกทอรีย่อย mpg นี่คือเส้นทางในสคริปต์การฝึกโมเดลของคุณ ซึ่งจะใช้ในการส่งออกโมเดลที่ผ่านการฝึกแล้ว
Vertex จะค้นหาตำแหน่งนี้เมื่อติดตั้งใช้งานโมเดล ตอนนี้คุณก็พร้อมสำหรับการฝึกแล้ว คลิกเริ่มการฝึกเพื่อเริ่มงานการฝึก ในส่วนการฝึกอบรมของคอนโซล คุณจะเห็นข้อมูลดังต่อไปนี้
6. ทำให้ปลายทางของโมเดลใช้งานได้
เมื่อตั้งค่างานการฝึก เราระบุจุดที่ Vertex AI ควรค้นหาชิ้นงานโมเดลที่ส่งออก Vertex จะสร้างทรัพยากรโมเดลตามเส้นทางชิ้นงานนี้ในไปป์ไลน์การฝึก ทรัพยากรโมเดลไม่ใช่โมเดลที่ใช้งานได้ แต่การมีโมเดลก็หมายความว่าคุณพร้อมที่จะทำให้โมเดลใช้งานได้ในปลายทาง ดูข้อมูลเพิ่มเติมเกี่ยวกับโมเดลและปลายทางใน Vertex AI ได้ในเอกสารประกอบ
ในขั้นตอนนี้ เราจะสร้างปลายทางสําหรับโมเดลที่ผ่านการฝึก เราสามารถใช้ข้อมูลนี้เพื่อรับการคาดการณ์เกี่ยวกับโมเดลผ่าน Vertex AI API
ขั้นตอนที่ 1: ติดตั้งใช้งานอุปกรณ์ปลายทาง
เมื่องานการฝึกเสร็จสมบูรณ์แล้ว คุณควรเห็นโมเดลชื่อ mpg (หรือชื่อที่คุณตั้งเอง) ในส่วนโมเดลของคอนโซล
เมื่องานการฝึกทำงาน Vertex สร้างทรัพยากรโมเดลให้คุณ คุณต้องทำให้ปลายทางใช้งานได้จึงจะใช้โมเดลนี้ได้ คุณมีปลายทางได้หลายรายการต่อโมเดล คลิกที่โมเดล แล้วคลิกทำให้ใช้งานได้ที่ปลายทาง
เลือกสร้างปลายทางใหม่ แล้วตั้งชื่อ เช่น v1 ปล่อยให้ระบบเลือกสิทธิ์การเข้าถึงเป็นมาตรฐาน แล้วคลิกต่อไป
ปล่อยการแยกการเข้าชมไว้ที่ 100 และป้อน 1 สำหรับจํานวนโหนดประมวลผลขั้นต่ำ ในส่วนประเภทเครื่อง ให้เลือก n1-standard-2 (หรือประเภทเครื่องที่ต้องการ) เลือกค่าเริ่มต้นที่เหลือไว้ แล้วคลิกต่อไป เราจะไม่เปิดใช้การตรวจสอบสําหรับโมเดลนี้ ดังนั้นให้คลิกทำให้ใช้งานได้เพื่อเริ่มการทําให้ปลายทางใช้งานได้
การนำส่งอุปกรณ์ปลายทางจะใช้เวลา 10-15 นาที และคุณจะได้รับอีเมลเมื่อนำส่งเสร็จสมบูรณ์ เมื่อปลายทางติดตั้งใช้งานเสร็จแล้ว คุณจะเห็นข้อมูลต่อไปนี้ซึ่งแสดงปลายทาง 1 รายการซึ่งใช้งานได้ในทรัพยากรโมเดล
ขั้นตอนที่ 2: รับการคาดการณ์ในโมเดลที่ติดตั้งใช้งาน
เราจะรับการคาดการณ์เกี่ยวกับโมเดลที่ผ่านการฝึกจากโน้ตบุ๊ก Python โดยใช้ Vertex Python API กลับไปที่อินสแตนซ์โน้ตบุ๊ก แล้วสร้างโน้ตบุ๊ก Python 3 จากตัวเปิดแอป โดยทำดังนี้
ในสมุดบันทึก ให้เรียกใช้คำสั่งต่อไปนี้ในเซลล์เพื่อติดตั้ง Vertex AI SDK
!pip3 install google-cloud-aiplatform --upgrade --user
จากนั้นเพิ่มเซลล์ในสมุดบันทึกเพื่อนำเข้า SDK และสร้างการอ้างอิงไปยังปลายทางที่คุณเพิ่งทำให้ใช้งานได้
from google.cloud import aiplatform
endpoint = aiplatform.Endpoint(
endpoint_name="projects/YOUR-PROJECT-NUMBER/locations/us-central1/endpoints/YOUR-ENDPOINT-ID"
)
คุณจะต้องแทนที่ค่า 2 ค่าในสตริง endpoint_name ด้านบนด้วยหมายเลขโปรเจ็กต์และปลายทาง คุณดูหมายเลขโปรเจ็กต์ได้โดยไปที่หน้าแดชบอร์ดของโปรเจ็กต์ แล้วดูค่าหมายเลขโปรเจ็กต์
คุณดูรหัสอุปกรณ์ปลายทางได้ในส่วนอุปกรณ์ปลายทางของคอนโซลที่นี่
สุดท้าย ให้ทําการคาดการณ์กับปลายทางโดยคัดลอกและเรียกใช้โค้ดด้านล่างในเซลล์ใหม่
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])
ตัวอย่างนี้มีค่ามาตรฐานอยู่แล้วซึ่งเป็นรูปแบบที่โมเดลของเราคาดไว้
เรียกใช้เซลล์นี้ แล้วคุณควรเห็นเอาต์พุตการคาดการณ์ประมาณ 16 ไมล์ต่อแกลลอน
🎉 ยินดีด้วย 🎉
คุณได้เรียนรู้วิธีใช้ Vertex AI เพื่อทำสิ่งต่อไปนี้แล้ว
- ฝึกโมเดลโดยระบุโค้ดการฝึกในคอนเทนเนอร์ที่กำหนดเอง คุณใช้โมเดล TensorFlow ในตัวอย่างนี้ แต่สามารถฝึกโมเดลที่สร้างด้วยเฟรมเวิร์กใดก็ได้โดยใช้คอนเทนเนอร์ที่กำหนดเอง
- ติดตั้งใช้งานโมเดล TensorFlow โดยใช้คอนเทนเนอร์ที่สร้างไว้ล่วงหน้าซึ่งเป็นส่วนหนึ่งของเวิร์กโฟลว์เดียวกับที่ใช้ฝึก
- สร้างปลายทางของโมเดลและสร้างการคาดการณ์
ดูข้อมูลเพิ่มเติมเกี่ยวกับส่วนต่างๆ ของ Vertex ได้ในเอกสารประกอบ
7. ล้างข้อมูล
หากต้องการใช้โน้ตบุ๊กที่สร้างในแท็บทดลองนี้ต่อไป เราขอแนะนำให้ปิดโน้ตบุ๊กเมื่อไม่ได้ใช้งาน จาก UI ของ Workbench ใน Cloud Console ให้เลือก Notebook แล้วเลือกหยุด
หากต้องการลบสมุดบันทึกทั้งหมด ให้คลิกปุ่ม "ลบ" ที่ด้านขวาบน
หากต้องการลบปลายทางที่ติดตั้งใช้งาน ให้ไปที่ส่วนปลายทางของคอนโซล Vertex AI แล้วคลิกปลายทางที่สร้าง จากนั้นเลือกยกเลิกการติดตั้งใช้งานโมเดลจากปลายทาง
หากต้องการลบที่เก็บข้อมูล ให้ใช้เมนูการนำทางใน Cloud Console เพื่อไปที่พื้นที่เก็บข้อมูล เลือกที่เก็บข้อมูล แล้วคลิกลบ
