1. ภาพรวม
ในแล็บนี้ คุณจะได้ใช้ Vertex AI เพื่อฝึกและแสดงโมเดล TensorFlow โดยใช้โค้ดในคอนเทนเนอร์ที่กำหนดเอง
แม้ว่าเราจะใช้ TensorFlow สำหรับโค้ดโมเดลที่นี่ แต่คุณก็สามารถแทนที่ด้วยเฟรมเวิร์กอื่นได้อย่างง่ายดาย
สิ่งที่คุณจะได้เรียนรู้
โดยคุณจะได้เรียนรู้วิธีต่อไปนี้
- สร้างและจัดเก็บโค้ดการฝึกโมเดลในคอนเทนเนอร์ใน Vertex Workbench
- ส่งงานการฝึกโมเดลที่กำหนดเองไปยัง Vertex AI
- ทำให้โมเดลที่ฝึกแล้วใช้งานได้ในปลายทาง และใช้ปลายทางนั้นเพื่อรับการคาดการณ์
ค่าใช้จ่ายทั้งหมดในการเรียกใช้ Lab นี้ใน 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 แล้วเลือกเปิดใช้หากยังไม่ได้เปิดใช้ คุณจะต้องใช้ข้อมูลนี้เพื่อสร้างอินสแตนซ์ Notebook
ขั้นตอนที่ 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
จากนั้นใน Notebook ที่ผู้ใช้จัดการ ให้คลิก Notebook ใหม่
จากนั้นเลือกประเภทอินสแตนซ์ TensorFlow Enterprise (พร้อม LTS) เวอร์ชันล่าสุดที่ไม่มี GPU ดังนี้
ใช้ตัวเลือกเริ่มต้น แล้วคลิกสร้าง
โมเดลที่เราจะฝึกและให้บริการในแล็บนี้สร้างขึ้นจากบทแนะนำนี้จากเอกสารประกอบของ TensorFlow บทแนะนำนี้ใช้ชุดข้อมูล MPG อัตโนมัติจาก Kaggle เพื่อคาดการณ์การประหยัดพลังงานของยานพาหนะ
4. สร้างคอนเทนเนอร์โค้ดการฝึก
เราจะส่งงานการฝึกนี้ไปยัง Vertex โดยใส่โค้ดการฝึกในคอนเทนเนอร์ Docker และพุชคอนเทนเนอร์นี้ไปยัง Google Container Registry การใช้แนวทางนี้ช่วยให้เราฝึกโมเดลที่สร้างด้วยเฟรมเวิร์กใดก็ได้
หากต้องการเริ่มต้น ให้เปิดหน้าต่างเทอร์มินัลในอินสแตนซ์ Notebook จากเมนู 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 Container TensorFlow Enterprise 2.3 คอนเทนเนอร์การเรียนรู้เชิงลึกใน Google Cloud มาพร้อมกับเฟรมเวิร์ก ML และวิทยาศาสตร์ข้อมูลทั่วไปหลายรายการที่ติดตั้งไว้ล่วงหน้า เวอร์ชันที่เราใช้มี TF Enterprise 2.3, Pandas, Scikit-learn และอื่นๆ หลังจากดาวน์โหลดอิมเมจดังกล่าวแล้ว Dockerfile นี้จะตั้งค่าจุดแรกเข้าสำหรับโค้ดการฝึก เรายังไม่ได้สร้างไฟล์เหล่านี้ ในขั้นตอนถัดไป เราจะเพิ่มโค้ดสำหรับการฝึกและส่งออกโมเดล
ขั้นตอนที่ 2: สร้าง Bucket ของ Cloud Storage
ในงานการฝึก เราจะส่งออกโมเดล TensorFlow ที่ฝึกแล้วไปยัง Bucket ของ Cloud Storage Vertex จะใช้ข้อมูลนี้เพื่ออ่านชิ้นงานโมเดลที่ส่งออกและทำให้โมเดลใช้งานได้ จากเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้เพื่อกำหนดตัวแปรสภาพแวดล้อมสำหรับโปรเจ็กต์ของคุณ โดยอย่าลืมแทนที่ your-cloud-project ด้วยรหัสโปรเจ็กต์ของคุณ
PROJECT_ID='your-cloud-project'
จากนั้นเรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัลเพื่อสร้างที่เก็บข้อมูลใหม่ในโปรเจ็กต์ แฟล็ก -l (ตำแหน่ง) มีความสำคัญเนื่องจากต้องอยู่ในภูมิภาคเดียวกันกับที่คุณจะทำให้ใช้งานได้ปลายทางโมเดลในภายหลังในบทแนะนำ
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 ด้วยชื่อของ Storage 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
เรียกใช้คอนเทนเนอร์ภายในอินสแตนซ์ Notebook เพื่อให้แน่ใจว่าทำงานได้อย่างถูกต้อง
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 ของคอนโซลระบบคลาวด์
ขั้นตอนที่ 1: เริ่มงานการฝึก
คลิกสร้างเพื่อป้อนพารามิเตอร์สำหรับงานการฝึกและโมเดลที่ใช้งานจริง
- ในส่วนชุดข้อมูล ให้เลือกไม่มีชุดข้อมูลที่มีการจัดการ
- จากนั้นเลือกการฝึกแบบกำหนดเอง (ขั้นสูง) เป็นวิธีการฝึก แล้วคลิกต่อไป
- คลิกต่อไป
ในขั้นตอนถัดไป ให้ป้อน mpg (หรือชื่อโมเดลที่คุณต้องการ) สำหรับชื่อโมเดล จากนั้นเลือกคอนเทนเนอร์ที่กำหนดเอง
ในกล่องข้อความอิมเมจคอนเทนเนอร์ ให้คลิกเรียกดู แล้วค้นหาอิมเมจ Docker ที่คุณเพิ่งอัปโหลดไปยัง Container Registry เว้นช่องที่เหลือว่างไว้ แล้วคลิกดำเนินการต่อ
เราจะไม่ใช้การปรับแต่งไฮเปอร์พารามิเตอร์ในบทแนะนำนี้ ดังนั้นให้ยกเลิกการเลือกช่อง "เปิดใช้การปรับแต่งไฮเปอร์พารามิเตอร์" แล้วคลิกต่อไป
ในการคำนวณและราคา ให้ปล่อยภูมิภาคที่เลือกไว้ตามเดิม แล้วเลือก n1-standard-4 เป็นประเภทเครื่อง
เว้นช่องโปรแกรมเร่งการเติบโตว่างไว้ แล้วเลือกดำเนินการต่อ เนื่องจากโมเดลในการสาธิตนี้ฝึกได้อย่างรวดเร็ว เราจึงใช้ประเภทเครื่องที่เล็กลง
ในขั้นตอนคอนเทนเนอร์การคาดการณ์ ให้เลือกคอนเทนเนอร์สำเร็จรูป แล้วเลือก 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: รับการคาดการณ์ในโมเดลที่ใช้งานจริง
เราจะรับการคาดการณ์ในโมเดลที่ฝึกจาก Notebook ของ Python โดยใช้ Vertex Python API กลับไปที่อินสแตนซ์ Notebook แล้วสร้าง Notebook Python 3 จาก Launcher โดยทำดังนี้
ใน Notebook ให้เรียกใช้คำสั่งต่อไปนี้ในเซลล์เพื่อติดตั้ง 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. ล้างข้อมูล
หากต้องการใช้ Notebook ที่สร้างขึ้นใน Lab นี้ต่อไป ขอแนะนำให้ปิดเมื่อไม่ได้ใช้งาน จาก UI ของ Workbench ใน Cloud Console ให้เลือก Notebook แล้วเลือกหยุด
หากต้องการลบ Notebook ทั้งหมด ให้คลิกปุ่มลบที่ด้านขวาบน
หากต้องการลบปลายทางที่ทำให้ใช้งานได้ ให้ไปที่ส่วนปลายทางของคอนโซล Vertex AI คลิกปลายทางที่สร้างขึ้น แล้วเลือกเลิกใช้งานโมเดลจากปลายทาง
หากต้องการลบ Storage Bucket ให้ใช้เมนูการนำทางใน Cloud Console ไปที่ Storage เลือก Bucket แล้วคลิกลบ
