Vertex AI: โมเดลผู้ร่วมจัดการประชุมบน VM เดียวกันสำหรับการคาดการณ์

1. ภาพรวม

ในแล็บนี้ คุณจะได้ใช้ฟีเจอร์โมเดลการโฮสต์ร่วมใน Vertex AI เพื่อโฮสต์โมเดลหลายรายการใน VM เดียวกันสำหรับการคาดการณ์ออนไลน์

สิ่งที่คุณจะได้เรียนรู้

โดยคุณจะได้เรียนรู้วิธีต่อไปนี้

สร้าง DeploymentResourcePool
ทำให้โมเดลใช้งานได้ภายใน DeploymentResourcePool

ค่าใช้จ่ายทั้งหมดในการเรียกใช้ Lab นี้ใน Google Cloud อยู่ที่ประมาณ $2

2. ข้อมูลเบื้องต้นเกี่ยวกับ Vertex AI

แล็บนี้ใช้ผลิตภัณฑ์ AI รุ่นล่าสุดที่พร้อมให้บริการใน Google Cloud Vertex AI ผสานรวมข้อเสนอ ML ใน Google Cloud เข้ากับประสบการณ์การพัฒนาที่ราบรื่น ก่อนหน้านี้ โมเดลที่ฝึกด้วย AutoML และโมเดลที่กำหนดเองจะเข้าถึงได้ผ่านบริการแยกต่างหาก ข้อเสนอใหม่นี้จะรวมทั้ง 2 อย่างไว้ใน API เดียว พร้อมกับผลิตภัณฑ์ใหม่อื่นๆ นอกจากนี้ คุณยังย้ายข้อมูลโปรเจ็กต์ที่มีอยู่ไปยัง Vertex AI ได้ด้วย หากมีข้อเสนอแนะ โปรดดูหน้าการสนับสนุน

Vertex AI มีผลิตภัณฑ์มากมายที่แตกต่างกันเพื่อรองรับเวิร์กโฟลว์ ML แบบครบวงจร ห้องทดลองนี้จะมุ่งเน้นที่ผลิตภัณฑ์ที่ไฮไลต์ไว้ด้านล่าง ได้แก่ การคาดการณ์และเวิร์กเบนช์

ภาพรวมผลิตภัณฑ์ Vertex

3. ภาพรวมกรณีการใช้งาน

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

การรองรับโมเดลการเป็นเจ้าของร่วมจะนำเสนอแนวคิดของ Deployment Resource Pool ซึ่งจัดกลุ่มโมเดลต่างๆ ไว้ด้วยกันเพื่อแชร์ทรัพยากรภายใน VM โมเดลจะแชร์ VM ได้หากแชร์ปลายทาง และยังแชร์ได้หากมีการทำให้ใช้งานได้ในปลายทางที่ต่างกัน ปัจจุบัน โมเดลในพูลทรัพยากรเดียวกันต้องมีอิมเมจคอนเทนเนอร์เดียวกัน ซึ่งรวมถึงเวอร์ชันเฟรมเวิร์กของคอนเทนเนอร์ที่สร้างไว้ล่วงหน้าของ Vertex Prediction นอกจากนี้ ในรุ่นนี้ยังรองรับเฉพาะคอนเทนเนอร์ที่สร้างไว้ล่วงหน้าสำหรับการคาดการณ์ของ Vertex ที่มีเฟรมเวิร์กโมเดล Tensorflow เท่านั้น ส่วนเฟรมเวิร์กโมเดลอื่นๆ และคอนเทนเนอร์ที่กำหนดเองยังไม่รองรับ

deployment_pool

4. ตั้งค่าสภาพแวดล้อม

คุณจะต้องมีโปรเจ็กต์ Google Cloud Platform ที่เปิดใช้การเรียกเก็บเงินเพื่อเรียกใช้ Codelab นี้ หากต้องการสร้างโปรเจ็กต์ ให้ทำตามวิธีการที่นี่

ขั้นตอนที่ 1: เปิดใช้ Compute Engine API

ไปที่ Compute Engine แล้วเลือกเปิดใช้หากยังไม่ได้เปิดใช้

ขั้นตอนที่ 2: เปิดใช้ Vertex AI API

ไปที่ส่วน Vertex AI ของ Cloud Console แล้วคลิกเปิดใช้ Vertex AI API

แดชบอร์ด Vertex AI

ขั้นตอนที่ 3: สร้างอินสแตนซ์ Vertex AI Workbench

จากส่วน Vertex AI ของ Cloud Console ให้คลิก Workbench

เปิดใช้ Notebooks API หากยังไม่ได้เปิด

Notebook_api

เมื่อเปิดใช้แล้ว ให้คลิก MANAGED NOTEBOOKS

Notebooks_UI

จากนั้นเลือก NOTEBOOK ใหม่

new_notebook

ตั้งชื่อ Notebook แล้วเลือกบัญชีบริการในส่วนสิทธิ์

create_notebook

เลือกการตั้งค่าขั้นสูง

ในส่วนความปลอดภัย ให้เลือก "เปิดใช้เทอร์มินัล" หากยังไม่ได้เปิดใช้

enable_terminal

คุณปล่อยให้การตั้งค่าขั้นสูงอื่นๆ ทั้งหมดเป็นไปตามเดิมได้

จากนั้นคลิกสร้าง ระบบจะใช้เวลา 2-3 นาทีในการจัดสรรอินสแตนซ์

เมื่อสร้างอินสแตนซ์แล้ว ให้เลือกเปิด JUPYTERLAB

open_jupyterlab

5. ฝึกโมเดล

ก่อนที่จะลองใช้ฟีเจอร์การเป็นเจ้าของร่วม เราต้องฝึกโมเดลและจัดเก็บอาร์ติแฟกต์ของโมเดลที่บันทึกไว้ใน Bucket ของ Cloud Storage ก่อน เราจะใช้ตัวเรียกใช้ Notebook ของ Workbench เพื่อเปิดใช้งานงานการฝึก

ขั้นตอนที่ 1: สร้าง Bucket ของ Cloud Storage

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

launcher_terminal

จากเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้เพื่อกำหนดตัวแปรสภาพแวดล้อมสำหรับโปรเจ็กต์ของคุณ โดยอย่าลืมแทนที่ your-cloud-project ด้วยรหัสโปรเจ็กต์

PROJECT_ID='your-cloud-project'

จากนั้นเรียกใช้คำสั่งต่อไปนี้เพื่อสร้างที่เก็บข้อมูลใหม่ในโปรเจ็กต์

BUCKET="gs://${PROJECT_ID}-bucket"
gsutil mb -l us-central1 $BUCKET

ขั้นตอนที่ 2: เปิดใช้การดำเนินการ Notebook

เปิดสมุดบันทึก TensorFlow 2 ใหม่จากตัวเรียกใช้ของอินสแตนซ์ Workbench

launcher_tf2

โค้ดด้านล่างจะฝึกตัวแยกประเภทความรู้สึกแบบไบนารี (เชิงบวกหรือเชิงลบ) ในชุดข้อมูลรีวิวภาพยนตร์ IMDB วางโค้ดลงใน Notebook

อย่าลืมแทนที่ {YOUR_BUCKET} ด้วยที่เก็บข้อมูลที่คุณสร้างในขั้นตอนก่อนหน้า (หรือที่เก็บข้อมูลอื่นในโปรเจ็กต์) ที่นี่คือที่ที่เราจะจัดเก็บอาร์ติแฟกต์ของโมเดลที่บันทึกไว้ ซึ่งเราจะต้องใช้ในภายหลังเมื่ออัปโหลดโมเดลไปยัง Vertex AI Model Registry

import numpy as np

import tensorflow_datasets as tfds
import tensorflow as tf

# REPLACE WITH YOUR BUCKET!
OUTPUT_PATH='gs://{YOUR_BUCKET}/model_output'

BUFFER_SIZE = 10000
BATCH_SIZE = 64
VOCAB_SIZE = 1000

# Load data
dataset, info = tfds.load('imdb_reviews', with_info=True,
                          as_supervised=True)
train_dataset, test_dataset = dataset['train'], dataset['test']

train_dataset = train_dataset.shuffle(BUFFER_SIZE).batch(BATCH_SIZE).prefetch(tf.data.AUTOTUNE)
test_dataset = test_dataset.batch(BATCH_SIZE).prefetch(tf.data.AUTOTUNE)

# Create text encoder
encoder = tf.keras.layers.TextVectorization(
    max_tokens=VOCAB_SIZE)
encoder.adapt(train_dataset.map(lambda text, label: text))

# Create model
model = tf.keras.Sequential([
    encoder,
    tf.keras.layers.Embedding(
        input_dim=len(encoder.get_vocabulary()),
        output_dim=64,
        # Use masking to handle the variable sequence lengths
        mask_zero=True),
    tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(64)),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(1)
])

# Compile model
model.compile(loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
              optimizer=tf.keras.optimizers.Adam(1e-4),
              metrics=['accuracy'])

# Fit model
history = model.fit(train_dataset, epochs=10,
                    validation_data=test_dataset,
                    validation_steps=30)

# Save model
model.save(OUTPUT_PATH)

จากนั้นเลือกปุ่มดำเนินการ

execute_nb

จากนั้นกําหนดค่าการดำเนินการดังนี้ แล้วคลิกส่ง

execution_config

คุณสามารถติดตามสถานะของงานการฝึกได้จากแท็บการดำเนินการในคอนโซล

execution_status

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

ขั้นตอนที่ 1: อัปโหลดโมเดล

เมื่อการดำเนินการเสร็จสมบูรณ์ ให้กลับไปที่ Notebook ของ Workbench เพื่ออัปโหลดโมเดล สร้าง Notebook ของ TensorFlow ใหม่

tf_nb

ก่อนอื่น ให้นำเข้า Vertex AI Python SDK

from google.cloud import aiplatform

จากนั้นอัปโหลดโมเดลโดยแทนที่ {YOUR_BUCKET} ด้วยที่เก็บข้อมูลที่คุณระบุในโค้ดการฝึก

# replace {YOUR_BUCKET}
model_1 = aiplatform.Model.upload(display_name='text-model-1',
                                  artifact_uri='gs://{YOUR_BUCKET}/model_output',
                                  serving_container_image_uri='us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-8:latest')

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

# replace {YOUR_BUCKET}
model_2 = aiplatform.Model.upload(display_name='text-model-2',
                                  artifact_uri='gs://{YOUR_BUCKET}/model_output',
                                  serving_container_image_uri='us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-8:latest')

ตอนนี้คุณควรเห็นทั้ง 2 โมเดลใน Vertex AI Model Registry สถานะการติดตั้งใช้งานว่างเปล่าเนื่องจากเรายังไม่ได้ติดตั้งใช้งานโมเดล

model_registry

ขั้นตอนที่ 2: สร้างปลายทาง

สร้างปลายทาง โปรดทราบว่าการดำเนินการนี้แตกต่างจากการติดตั้งใช้งานโมเดลไปยังปลายทาง

endpoint = aiplatform.Endpoint.create('cohost-endpoint')

เมื่อสร้างปลายทางแล้ว คุณจะเห็นปลายทางนั้นในคอนโซล

console_endpoint

ขั้นตอนที่ 3: สร้าง DeploymentResourcePool

คุณสร้าง DeploymentResourcePool ได้ด้วยคำสั่งต่อไปนี้ อย่าลืมแทนที่ {YOUR_PROJECT} ด้วยรหัสโปรเจ็กต์ของคุณ

# replace {YOUR_PROJECT}
PROJECT_ID={YOUR_PROJECT}
REGION="us-central1"
VERTEX_API_URL=REGION + "-aiplatform.googleapis.com"
VERTEX_PREDICTION_API_URL=REGION + "-prediction-aiplatform.googleapis.com"
MULTI_MODEL_API_VERSION="v1beta1"

# Give the pool a name
DEPLOYMENT_RESOURCE_POOL_ID="my-resource-pool"

import json
import pprint
pp = pprint.PrettyPrinter(indent=4)

CREATE_RP_PAYLOAD = {
  "deployment_resource_pool":{
    "dedicated_resources":{
      "machine_spec":{
        "machine_type":"n1-standard-4"
      },
      "min_replica_count":1,
      "max_replica_count":2
    }
  },
  "deployment_resource_pool_id":DEPLOYMENT_RESOURCE_POOL_ID
}
CREATE_RP_REQUEST=json.dumps(CREATE_RP_PAYLOAD)
pp.pprint("CREATE_RP_REQUEST: " + CREATE_RP_REQUEST)

!curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://{VERTEX_API_URL}/{MULTI_MODEL_API_VERSION}/projects/{PROJECT_ID}/locations/{REGION}/deploymentResourcePools \
-d '{CREATE_RP_REQUEST}'

คุณดูพูลได้โดยเรียกใช้

!curl -X GET \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://{VERTEX_API_URL}/{MULTI_MODEL_API_VERSION}/projects/{PROJECT_ID}/locations/{REGION}/deploymentResourcePools/{DEPLOYMENT_RESOURCE_POOL_ID}

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

เมื่อสร้างพูลทรัพยากรแล้ว เราจะสามารถติดตั้งใช้งานโมเดลภายในพูลทรัพยากรได้

ก่อนอื่น เราจะติดตั้งใช้งาน model_1 อย่าลืมแทนที่ MODEL_1_ID และ ENDPOINT_ID ด้วยรหัสที่เกี่ยวข้อง

MODEL_1_ID="{MODEL_1_ID}"
ENDPOINT_ID="{ENDPOINT_ID}"

คำสั่งต่อไปนี้จะทำให้ model_1 ทำการติดตั้งใช้งานไปยังปลายทางภายในพูลทรัพยากร

MODEL_NAME = "projects/{project_id}/locations/{region}/models/{model_id}".format(project_id=PROJECT_ID, region=REGION, model_id=MODEL_1_ID)
SHARED_RESOURCE = "projects/{project_id}/locations/{region}/deploymentResourcePools/{deployment_resource_pool_id}".format(project_id=PROJECT_ID, region=REGION, deployment_resource_pool_id=DEPLOYMENT_RESOURCE_POOL_ID)

DEPLOY_MODEL_PAYLOAD = {
  "deployedModel": {
    "model": MODEL_NAME,
    "shared_resources": SHARED_RESOURCE
  },
  "trafficSplit": {
    "0": 100
  }
}
DEPLOY_MODEL_REQUEST=json.dumps(DEPLOY_MODEL_PAYLOAD)
pp.pprint("DEPLOY_MODEL_REQUEST: " + DEPLOY_MODEL_REQUEST)

!curl -X POST \
 -H "Authorization: Bearer $(gcloud auth print-access-token)" \
 -H "Content-Type: application/json" \
https://{VERTEX_API_URL}/{MULTI_MODEL_API_VERSION}/projects/{PROJECT_ID}/locations/{REGION}/endpoints/{ENDPOINT_ID}:deployModel \
-d '{DEPLOY_MODEL_REQUEST}'

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

model_1_endpoint

จากนั้นเราจะติดตั้งใช้งาน model_2 ภายในกลุ่มการติดตั้งใช้งานเดียวกันได้ เราจะติดตั้งใช้งานในปลายทางเดียวกับ model_1 อย่างไรก็ตาม คุณยังเลือกที่จะติดตั้งใช้งานmodel_2ไปยังปลายทางอื่นภายในพูลทรัพยากรเดียวกันได้ด้วย

อัปเดต MODEL_ID ด้วยรหัสของ model_2 คุณดูรหัสนี้ได้โดยเรียกใช้ model_2.name

MODEL_2_ID="{MODEL_2_ID}"

จากนั้นให้ทำให้ model_2 ใช้งานได้ เนื่องจากเราได้ติดตั้งใช้งาน model_1 ในอุปกรณ์ปลายทางแล้ว เราจึงต้องอัปเดต trafficSplit เพื่อให้ระบบแยกการเข้าชมระหว่างโมเดลทั้ง 2 รายการ เราไม่จำเป็นต้องอัปเดต trafficSplit หากเลือกที่จะติดตั้งใช้งาน model_2 ไปยังปลายทางอื่นภายในพูลทรัพยากรเดียวกัน

หากต้องการอัปเดตการแยกการเข้าชม คุณจะต้องกำหนดรหัส DeployedModel สำหรับ model_1 โปรดทราบว่ารหัสนี้แตกต่างจากรหัสโมเดล

DEPLOYED_MODEL_1_ID = {DEPLOYED_MODEL_1_ID}

จากนั้นเรียกใช้คำสั่งต่อไปนี้เพื่อติดตั้งใช้งานโมเดลที่ 2

MODEL_NAME = "projects/{project_id}/locations/{region}/models/{model_id}".format(project_id=PROJECT_ID, region=REGION, model_id=MODEL_2_ID)
SHARED_RESOURCE = "projects/{project_id}/locations/{region}/deploymentResourcePools/{deployment_resource_pool_id}".format(project_id=PROJECT_ID, region=REGION, deployment_resource_pool_id=DEPLOYMENT_RESOURCE_POOL_ID)

#`trafficSplit` is a map from a DeployedModel's ID to the percentage of this Endpoint's traffic that should be forwarded to that DeployedModel.
# The traffic percentage values for an endpoint must add up to 100.
# The key for the model being deployed is "0".

DEPLOY_MODEL_PAYLOAD = {
  "deployedModel": {
    "model": MODEL_NAME,
    "shared_resources": SHARED_RESOURCE
  },
  "trafficSplit": {
    "0": 50,
    DEPLOYED_MODEL_1_ID: 50
  }
}
DEPLOY_MODEL_REQUEST=json.dumps(DEPLOY_MODEL_PAYLOAD)
pp.pprint("DEPLOY_MODEL_REQUEST: " + DEPLOY_MODEL_REQUEST)

!curl -X POST \
 -H "Authorization: Bearer $(gcloud auth print-access-token)" \
 -H "Content-Type: application/json" \
https://{VERTEX_API_URL}/{MULTI_MODEL_API_VERSION}/projects/{PROJECT_ID}/locations/{REGION}/endpoints/{ENDPOINT_ID}:deployModel \
-d '{DEPLOY_MODEL_REQUEST}'

ในตัวอย่างนี้ โมเดลทั้ง 2 รายการได้รับการติดตั้งใช้งานในปลายทางเดียวกัน แต่คุณยังโฮสต์ร่วมโมเดลไปยังพูลทรัพยากรเดียวกันที่ติดตั้งใช้งานในปลายทางที่แตกต่างกันได้ด้วย ในกรณีนี้ คุณจึงไม่ต้องกังวลเรื่องการแยกการรับส่งข้อมูล

หลังจากที่ติดตั้งใช้งานโมเดลที่ 2 แล้ว คุณจะเห็นโมเดลทั้ง 2 รายการในคอนโซล

deployed_models

ขั้นตอนที่ 5: รับการคาดการณ์

ขั้นตอนสุดท้ายคือการทดสอบปลายทางและรับการคาดการณ์

ก่อนอื่น ให้กำหนดประโยคทดสอบ

x_test=['The movie was cool. The animation and the graphics were out of this world. I would recommend this movie.']

จากนั้นเรียกใช้การคาดการณ์ในปลายทาง ซึ่งจะแสดงผลการคาดการณ์จากโมเดลใดโมเดลหนึ่งที่ติดตั้งใช้งานในปลายทาง

endpoint.predict(instances=x_test)

🎉 ยินดีด้วย 🎉

คุณได้เรียนรู้วิธีใช้ Vertex AI เพื่อทำสิ่งต่อไปนี้แล้ว

โฮสต์ร่วมโมเดลใน VM เดียวกันสำหรับการคาดการณ์ออนไลน์

ดูข้อมูลเพิ่มเติมเกี่ยวกับส่วนต่างๆ ของ Vertex ได้ที่เอกสารประกอบ

7. ล้างข้อมูล

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

undeploy_model

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

หยุดอินสแตนซ์

หากต้องการลบ Storage Bucket ให้ใช้เมนูการนำทางใน Cloud Console โดยไปที่ Storage เลือก Bucket แล้วคลิกลบ

ลบพื้นที่เก็บข้อมูล