Vertex AI: การฝึกและการให้บริการโมเดลที่กำหนดเอง

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 แบบครบวงจร ห้องทดลองนี้จะมุ่งเน้นที่ผลิตภัณฑ์ที่ไฮไลต์ด้านล่าง ซึ่งได้แก่ การฝึกอบรม การคาดการณ์ และ Workbench

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 และเข้ารหัสลงในไดเรกทอรีดังกล่าว:

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 ด้วยรหัสโปรเจ็กต์

คุณรับรหัสโปรเจ็กต์ได้โดยเรียกใช้ gcloud config list --format 'value(core.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 ด้วยชื่อของที่เก็บข้อมูลที่คุณสร้างขึ้นในขั้นตอนก่อนหน้า

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 Console โดยทำดังนี้

ขั้นตอนที่ 1: เริ่มต้นงานการฝึก

คลิกสร้างเพื่อป้อนพารามิเตอร์สําหรับงานการฝึกและโมเดลที่ติดตั้งใช้งาน

• ในส่วนชุดข้อมูล ให้เลือกไม่มีชุดข้อมูลที่มีการจัดการ
• จากนั้นเลือกการฝึกที่กำหนดเอง (ขั้นสูง) เป็นวิธีการฝึก แล้วคลิกต่อไป
• คลิกต่อไป

ในขั้นตอนถัดไป ให้ป้อน mpg (หรืออะไรก็ตามที่คุณต้องการเรียกโมเดลของคุณ) สำหรับชื่อโมเดล จากนั้นเลือกคอนเทนเนอร์ที่กำหนดเอง

ในกล่องข้อความอิมเมจคอนเทนเนอร์ ให้คลิกเรียกดู และค้นหาอิมเมจ Docker ที่คุณเพิ่งอัปโหลดไปยัง Container Registry เว้นช่องที่เหลือว่างไว้และคลิกดำเนินการต่อ

เราจะไม่ใช้การปรับแต่งไฮเปอร์พารามิเตอร์ในบทแนะนำนี้ ดังนั้นให้ปล่อยช่อง "เปิดใช้การปรับแต่งไฮเปอร์พารามิเตอร์" ให้ไม่เลือก แล้วคลิกต่อไป

ในการประมวลผลและราคา ให้ปล่อยภูมิภาคที่เลือกไว้ตามเดิมและเลือก n1-standard-4 เป็นประเภทเครื่อง

เว้นช่อง Accelerator ว่างไว้และเลือกดำเนินการต่อ เนื่องจากโมเดลในการสาธิตนี้ฝึกได้อย่างรวดเร็ว เราจึงใช้ประเภทเครื่องที่เล็กกว่า

หมายเหตุ: คุณสามารถทดสอบกับประเภทเครื่องและ GPU ที่มีขนาดใหญ่กว่าได้หากต้องการ หากใช้ GPU คุณจะต้องใช้อิมเมจคอนเทนเนอร์พื้นฐานที่เปิดใช้ GPU

ในขั้นตอนคอนเทนเนอร์การคาดการณ์ ให้เลือกคอนเทนเนอร์สำเร็จรูป แล้วเลือก TensorFlow 2.6

ปล่อยการตั้งค่าเริ่มต้นสำหรับคอนเทนเนอร์ที่สร้างไว้ล่วงหน้าไว้ตามเดิม ในส่วนไดเรกทอรีโมเดล ให้ป้อนที่เก็บข้อมูล GCS ด้วยไดเรกทอรีย่อย mpg เส้นทางในสคริปต์การฝึกโมเดลที่คุณส่งออกโมเดลที่ผ่านการฝึกมีดังนี้

Vertex จะดูในตำแหน่งนี้เมื่อทำให้โมเดลของคุณใช้งานได้ ตอนนี้คุณก็พร้อมสำหรับการฝึกแล้ว คลิกเริ่มต้นการฝึกเพื่อเริ่มต้นงานการฝึก ในส่วนการฝึกอบรมของคอนโซล คุณจะเห็นข้อมูลดังต่อไปนี้

งานการฝึกอบรมจะใช้เวลาประมาณ 10-15 นาทีจึงจะเสร็จสมบูรณ์

6. ทำให้ปลายทางของโมเดลใช้งานได้

เมื่อตั้งค่างานการฝึก เราระบุจุดที่ Vertex AI ควรค้นหาชิ้นงานโมเดลที่ส่งออก Vertex จะสร้างทรัพยากรโมเดลตามเส้นทางเนื้อหานี้ในฐานะส่วนหนึ่งของไปป์ไลน์การฝึก ตัวทรัพยากรของโมเดลเองไม่ใช่โมเดลที่ทำให้ใช้งานได้ แต่เมื่อมีโมเดลแล้ว คุณก็พร้อมที่จะทำให้โมเดลนั้นใช้งานได้ที่ปลายทาง ดูข้อมูลเพิ่มเติมเกี่ยวกับโมเดลและปลายทางใน Vertex AI ได้ในเอกสารประกอบ

ในขั้นตอนนี้ เราจะสร้างปลายทางสําหรับโมเดลที่ผ่านการฝึก เราใช้ข้อมูลนี้เพื่อรับการคาดการณ์ในโมเดลของเราผ่าน Vertex AI API ได้

ขั้นตอนที่ 1: ทำให้ปลายทางใช้งานได้

เมื่องานการฝึกเสร็จสมบูรณ์แล้ว คุณควรเห็นโมเดลชื่อ mpg (หรือชื่อที่คุณตั้งเอง) ในส่วนโมเดลของคอนโซล

เมื่องานการฝึกทำงาน Vertex สร้างทรัพยากรโมเดลให้คุณ หากต้องการใช้โมเดลนี้ คุณต้องติดตั้งใช้งานอุปกรณ์ปลายทาง คุณมีปลายทางได้หลายรายการต่อโมเดล คลิกที่โมเดล แล้วคลิกทำให้ใช้งานได้ที่ปลายทาง

เลือกสร้างปลายทางใหม่ แล้วตั้งชื่อ เช่น v1 ปล่อยให้ระบบเลือกสิทธิ์การเข้าถึงเป็นมาตรฐาน แล้วคลิกต่อไป

ปล่อยการแยกการเข้าชมไว้ที่ 100 แล้วป้อน 1 สำหรับจำนวนโหนดประมวลผลขั้นต่ำ ในส่วนประเภทเครื่อง ให้เลือก n1-standard-2 (หรือประเภทเครื่องที่ต้องการ) ปล่อยค่าเริ่มต้นที่เหลือไว้ตามเดิม แล้วคลิกต่อไป เราจะไม่เปิดใช้การตรวจสอบสําหรับโมเดลนี้ ดังนั้นให้คลิกทำให้ใช้งานได้เพื่อเริ่มการทําให้ปลายทางใช้งานได้

การนำส่งอุปกรณ์ปลายทางจะใช้เวลา 10-15 นาที และคุณจะได้รับอีเมลเมื่อนำส่งเสร็จสมบูรณ์ เมื่อปลายทางทำให้ใช้งานได้เสร็จแล้ว คุณจะเห็นปลายทาง 1 รายการที่แสดงปลายทาง 1 รายการซึ่งใช้งานได้ในทรัพยากรโมเดล

ขั้นตอนที่ 2: รับการคาดการณ์บนโมเดลที่ทำให้ใช้งานได้

เราจะรับการคาดการณ์ในโมเดลที่ฝึกจากสมุดบันทึก Python โดยใช้ Vertex Python API กลับไปที่อินสแตนซ์สมุดบันทึกแล้วสร้างสมุดบันทึก Python 3 จาก Launcher โดยทำดังนี้

ในสมุดบันทึก ให้เรียกใช้คำสั่งต่อไปนี้ในเซลล์เพื่อติดตั้ง 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. ล้างข้อมูล

หากต้องการใช้สมุดบันทึกที่คุณสร้างไว้ในห้องทดลองนี้ต่อไป ขอแนะนำให้คุณปิดสมุดบันทึกเมื่อไม่ได้ใช้งาน เลือกสมุดบันทึกแล้วเลือกหยุดจาก Workbench UI ใน Cloud Console

หากคุณต้องการลบสมุดบันทึกทั้งหมด ให้คลิกปุ่ม ลบ ที่ด้านบนขวา

หากต้องการลบปลายทางที่ทำให้ใช้งานได้แล้ว ให้ไปที่ส่วนปลายทางของคอนโซล Vertex AI แล้วคลิกปลายทางที่คุณสร้างขึ้น จากนั้นเลือกยกเลิกการทำให้โมเดลใช้งานได้จากปลายทาง

หากต้องการลบที่เก็บข้อมูลของพื้นที่เก็บข้อมูล โดยใช้เมนูการนำทางใน Cloud Console จากนั้นเรียกดูพื้นที่เก็บข้อมูล เลือกที่เก็บข้อมูล แล้วคลิกลบ: