หน้านี้ได้รับการแปลโดย Cloud Translation API

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

1. ภาพรวม

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

สิ่งที่ได้เรียนรู้

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

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

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

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

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

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

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

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

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

การรองรับโมเดลการโฮสต์ร่วมนำเสนอแนวคิดของ Deployment Resource Pool ซึ่งจัดกลุ่มโมเดลเข้าด้วยกันเพื่อแชร์ทรัพยากรภายใน VM โมเดลจะแชร์ VM ได้หากแชร์ปลายทาง และหากทำให้โมเดลใช้งานได้ที่ปลายทางที่ต่างกันด้วย ปัจจุบันโมเดลในพูลทรัพยากรเดียวกันต้องมีอิมเมจคอนเทนเนอร์เดียวกัน รวมถึงคอนเทนเนอร์ Vertex Prediction เวอร์ชันเฟรมเวิร์กที่สร้างไว้ล่วงหน้า นอกจากนี้ เวอร์ชันนี้รองรับเฉพาะคอนเทนเนอร์ที่สร้างไว้ล่วงหน้าสำหรับ Vertex Prediction ที่มีเฟรมเวิร์กโมเดล 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

เมื่อเปิดใช้แล้ว ให้คลิกสมุดบันทึกที่มีการจัดการ

Notebooks_UI

จากนั้นเลือกสมุดบันทึกใหม่

new_notebook

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

create_notebook

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

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

enable_terminal

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

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

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

open_jupyterlab

5. ฝึกโมเดล

ก่อนที่จะลองใช้ฟีเจอร์การโฮสต์ร่วม เราต้องฝึกโมเดลและจัดเก็บอาร์ติแฟกต์ของโมเดลที่บันทึกไว้ลงในที่เก็บข้อมูล Cloud Storage ก่อน เราจะใช้ผู้ดำเนินการสมุดบันทึก Workbench เพื่อเริ่มงานการฝึก

ขั้นตอนที่ 1: สร้างที่เก็บข้อมูล Cloud Storage

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

launcher_terminal

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

PROJECT_ID='your-cloud-project'

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

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

ขั้นตอนที่ 2: เปิดการดำเนินการของสมุดบันทึก

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

launcher_tf2

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

อย่าลืมแทนที่ {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: อัปโหลดโมเดล

เมื่อการดำเนินการเสร็จสมบูรณ์แล้ว ให้กลับไปที่สมุดบันทึก Workbench เพื่ออัปโหลดโมเดล สร้างสมุดบันทึก 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 ใช้งานได้ที่ปลายทางอื่นภายในพูลทรัพยากรเดียวกัน

หากต้องการอัปเดตการแยกการเข้าชม คุณจะต้องกำหนดรหัสโมเดลที่ทำให้ใช้งานได้สำหรับ 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

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

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

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

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