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

การรองรับการโฮสต์โมเดลร่วมกันจะแนะนำแนวคิดเกี่ยวกับพูลทรัพยากรสำหรับการติดตั้งใช้งาน ซึ่งจะจัดกลุ่มโมเดลต่างๆ เข้าด้วยกันเพื่อแชร์ทรัพยากรภายใน 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: เริ่มการเรียกใช้ Notebook

เปิดสมุดบันทึกใหม่ของ 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}'

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

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 เพื่อไปที่พื้นที่เก็บข้อมูล เลือกที่เก็บข้อมูล แล้วคลิกลบ

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