1. खास जानकारी
इस लैब में, आपको Vertex AI में को-होस्टिंग मॉडल की सुविधा का इस्तेमाल करना होगा. इससे ऑनलाइन अनुमान के लिए, एक ही वीएम पर कई मॉडल होस्ट किए जा सकेंगे.
आपको ये सब सीखने को मिलेगा
आपको, इनके बारे में जानकारी मिलेगी:
DeploymentResourcePoolबनाएंDeploymentResourcePoolमें मॉडल डिप्लॉय करें
Google Cloud पर इस लैब को चलाने की कुल लागत करीब $2 है.
2. Vertex AI के बारे में जानकारी
यह लैब, Google Cloud पर उपलब्ध एआई (AI) प्रॉडक्ट के सबसे नए वर्शन का इस्तेमाल करती है. Vertex AI, Google Cloud के सभी मशीन लर्निंग प्लैटफ़ॉर्म को आसानी से डेवलप करने के लिए इंटिग्रेट करता है. पहले, AutoML और कस्टम मॉडल की मदद से ट्रेन किए गए मॉडल अलग-अलग सेवाओं से ऐक्सेस किए जा सकते थे. नई सेवा में, एक एपीआई से नए प्रॉडक्ट और इन दोनों का इस्तेमाल किया जा सकता है. आपके पास मौजूदा प्रोजेक्ट को Vertex AI पर माइग्रेट करने का विकल्प भी है. अगर आपका कोई सुझाव, राय या शिकायत है, तो कृपया सहायता पेज पर जाएं.
Vertex AI में कई तरह के प्रॉडक्ट शामिल हैं, जो मशीन लर्निंग के वर्कफ़्लो को मैनेज करने में मदद करते हैं. यह लैब नीचे हाइलाइट किए गए प्रॉडक्ट पर फ़ोकस करेगी: अनुमान और वर्कबेंच
3. इस्तेमाल के उदाहरण की खास जानकारी
Vertex AI के अनुमान की सेवा में मॉडल को डिप्लॉय करते समय, हर मॉडल को डिफ़ॉल्ट रूप से उसकी अपनी वर्चुअल मशीन (वीएम) पर डिप्लॉय किया जाता है. ज़्यादा किफ़ायती होस्टिंग के लिए, एक ही वीएम पर कई मॉडल होस्ट किए जा सकते हैं. इससे मेमोरी और कंप्यूटेशनल रिसॉर्स का बेहतर इस्तेमाल होता है. एक ही वीएम के लिए कितने मॉडल डिप्लॉय किए जाएंगे, यह मॉडल के साइज़ और ट्रैफ़िक पैटर्न पर निर्भर करेगा. हालांकि, यह सुविधा खास तौर पर उन मामलों में काम आती है जहां डिप्लॉय किए गए कई मॉडल कम ट्रैफ़िक वाले हों.
को-होस्टिंग मॉडल सपोर्ट में, डिप्लॉयमेंट रिसॉर्स पूल का कॉन्सेप्ट जोड़ा गया है. यह सुविधा, वर्चुअल मशीन (वीएम) में संसाधनों को शेयर करने के लिए, मॉडल को एक साथ ग्रुप में बांटती है. अगर मॉडल एक एंडपॉइंट शेयर करते हैं और वे अलग-अलग एंडपॉइंट पर डिप्लॉय किए जाते हैं, तब भी वे वीएम शेयर कर सकते हैं. फ़िलहाल, एक ही रिसॉर्स पूल के मॉडल में एक ही कंटेनर इमेज होनी चाहिए, जिसमें Vertex अनुमान पहले से बने कंटेनर का फ़्रेमवर्क वर्शन भी शामिल है. इसके अलावा, इस रिलीज़ में सिर्फ़ TensorFlow के मॉडल फ़्रेमवर्क का इस्तेमाल करके, Vertex अनुमान पहले से बनाए गए कंटेनर काम करते हैं. हालांकि, फ़िलहाल अन्य मॉडल फ़्रेमवर्क और कस्टम कंटेनर काम नहीं करते.
4. अपना एनवायरमेंट सेट अप करें
इस कोडलैब को चलाने के लिए, आपके पास Google Cloud Platform का ऐसा प्रोजेक्ट होना चाहिए जिसमें बिलिंग की सुविधा चालू हो. प्रोजेक्ट बनाने के लिए, यहां दिए गए निर्देशों का पालन करें.
पहला चरण: Compute Engine API चालू करना
Compute Engine पर जाएं और अगर यह पहले से चालू नहीं है, तो चालू करें को चुनें.
दूसरा चरण: Vertex AI API को चालू करना
अपने Cloud Console के Vertex AI सेक्शन पर जाएं और Vertex AI API को चालू करें पर क्लिक करें.
तीसरा चरण: Vertex AI Workbench इंस्टेंस बनाना
अपने Cloud Console के Vertex AI सेक्शन में जाकर, Workbench पर क्लिक करें:
अगर Notebooks API पहले से चालू नहीं है, तो उसे चालू करें.
इसके बाद, मैनेज की गई किताबें पर क्लिक करें:
इसके बाद, नई नोटबुक चुनें.
अपनी नोटबुक को कोई नाम दें और अनुमति में जाकर सेवा खाता चुनें
बेहतर सेटिंग चुनें.
सुरक्षा में जाकर, "टर्मिनल चालू करें" चुनें अगर यह पहले से चालू नहीं है.
अन्य सभी बेहतर सेटिंग को वैसे ही रहने दिया जा सकता है.
इसके बाद, बनाएं पर क्लिक करें. इस इंस्टेंस को सेट अप होने में कुछ मिनट लगेंगे.
इंस्टेंस बनाने के बाद, JUPYTERLAB खोलें को चुनें.
5. ट्रेन का मॉडल
को-होस्टिंग की सुविधा आज़माने से पहले, हमें मॉडल को ट्रेनिंग देनी होगी. साथ ही, सेव किए गए मॉडल के आर्टफ़ैक्ट को Cloud Storage बकेट में सेव करना होगा. हम ट्रेनिंग जॉब लॉन्च करने के लिए, वर्कबेंच नोटबुक एक्सिटर का इस्तेमाल करेंगे.
पहला चरण: Cloud Storage बकेट बनाना
अगर आपके प्रोजेक्ट में कोई मौजूदा बकेट है जिसका इस्तेमाल करना है, तो इस चरण को छोड़ा जा सकता है. अगर ऐसा नहीं है, तो लॉन्चर से एक नया टर्मिनल सेशन खोलें.
अपने प्रोजेक्ट के लिए env वैरिएबल तय करने के लिए, टर्मिनल से इन्हें चलाएं. साथ ही, your-cloud-project को अपने प्रोजेक्ट के आईडी से बदलना न भूलें:
PROJECT_ID='your-cloud-project'
इसके बाद, अपने प्रोजेक्ट में एक नया बकेट बनाने के लिए, यहां दिया गया कमांड चलाएं.
BUCKET="gs://${PROJECT_ID}-bucket"
gsutil mb -l us-central1 $BUCKET
दूसरा चरण: नोटबुक को एक्ज़ीक्यूट करने की सुविधा लॉन्च करना
अपने Workbench इंस्टेंस के लॉन्चर से, एक नई TensorFlow 2 नोटबुक खोलें.
नीचे दिया गया कोड 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)
इसके बाद, लागू करें बटन चुनें.
इसके बाद, लागू करने की प्रोसेस को नीचे बताए गए तरीके से कॉन्फ़िगर करें और सबमिट करें पर क्लिक करें
कंसोल में मौजूद निष्पादन टैब से, आप अपने प्रशिक्षण काम की स्थिति को ट्रैक कर सकते हैं.
6. मॉडल डिप्लॉय करें
पहला चरण: मॉडल अपलोड करना
एक्ज़ीक्यूशन पूरा होने के बाद, मॉडल अपलोड करने के लिए वर्कबेंच नोटबुक पर वापस जाएं. एक नई TensorFlow नोटबुक बनाएं.
सबसे पहले, 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')
दिखाने के लिए, हम इस मॉडल को दो बार अपलोड करेंगे. ऐसा करने से, Vertex AI में दो अलग-अलग मॉडल रिसॉर्स तैयार हो जाएंगे. ऐसा इसलिए किया गया है, ताकि हम डिप्लॉयमेंट रिसॉर्स पूल में मौजूद एक एंडपॉइंट पर कई मॉडल डिप्लॉय करने की जांच कर सकें. असल में, आपके पास सेव किए गए एक ही आर्टफ़ैक्ट से मॉडल बनाने के बजाय, दो अलग-अलग मॉडल होते हैं. हालांकि, यह एक शॉर्टकट है. इसलिए, हमें ट्रेनिंग को फिर से शुरू करने की ज़रूरत नहीं है. इसके अलावा, आपके पास एक ही डिप्लॉयमेंट रिसॉर्स पूल में मौजूद अलग-अलग एंडपॉइंट पर दो मॉडल को डिप्लॉय करने का विकल्प भी है.
# 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')
Vertex AI Model Registry में, अब आपको दोनों मॉडल दिखेंगे. डिप्लॉयमेंट की स्थिति खाली है, क्योंकि हमने अब तक मॉडल डिप्लॉय नहीं किए हैं.
दूसरा चरण: एंडपॉइंट बनाना
एंडपॉइंट बनाएं. ध्यान दें कि यह मॉडल को एंडपॉइंट पर डिप्लॉय करने से अलग है.
endpoint = aiplatform.Endpoint.create('cohost-endpoint')
एंडपॉइंट बन जाने पर, यह आपको कंसोल में दिखेगा.
तीसरा चरण: 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}
चौथा चरण: मॉडल को एंडपॉइंट पर डिप्लॉय करना
अब रिसॉर्स पूल बन गया है, इसलिए हम रिसॉर्स पूल में मॉडल को डिप्लॉय कर सकते हैं.
सबसे पहले, हम 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_2 को उसी डिप्लॉयमेंट पूल में डिप्लॉय कर सकते हैं. हम इसे उसी एंडपॉइंट पर डिप्लॉय करेंगे जिस पर model_1 किया गया है. हालांकि, आपके पास model_2 को उसी रिसॉर्स पूल में मौजूद किसी दूसरे एंडपॉइंट पर डिप्लॉय करने का विकल्प भी है.
MODEL_ID को model_2 के आईडी से अपडेट करें. फिर से, model_2.name चलाकर यह आईडी पाया जा सकता है
MODEL_2_ID="{MODEL_2_ID}"
इसके बाद, model_2 को डिप्लॉय करें. हमने एंडपॉइंट पर पहले से ही model_1 डिप्लॉय किया हुआ है. इसलिए, हमें trafficSplit को अपडेट करना होगा, ताकि ट्रैफ़िक को दो मॉडल में बांटा जा सके. अगर हम model_2 को उसी रिसॉर्स पूल में मौजूद किसी दूसरे एंडपॉइंट पर डिप्लॉय करने का विकल्प चुनते हैं, तो हमें trafficSplit को अपडेट नहीं करना होगा.
ट्रैफ़िक का बंटवारा अपडेट करने के लिए, आपको model_1 के लिए DeployedModel आईडी तय करना होगा. ध्यान दें कि यह मॉडल आईडी से अलग होता है.
DEPLOYED_MODEL_1_ID = {DEPLOYED_MODEL_1_ID}
इसके बाद, दूसरे मॉडल को डिप्लॉय करने के लिए, नीचे दिया गया तरीका अपनाएं.
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}'
फिर से, इस उदाहरण में दोनों मॉडल को एक ही एंडपॉइंट पर डिप्लॉय किया गया था. हालांकि, एक ही रिसोर्स पूल में मॉडल को को-होस्ट भी किया जा सकता है जो अलग-अलग एंडपॉइंट पर डिप्लॉय किया गया है. ऐसे में आपको ट्रैफ़िक के बंटवारे की चिंता नहीं करनी होगी.
दूसरा मॉडल डिप्लॉय होने के बाद, आपको कंसोल में दोनों मॉडल दिखेंगे.
पांचवां चरण: अनुमान पाना
आखिरी कदम एंडपॉइंट की जांच करना और अनुमान पाना है.
सबसे पहले, एक टेस्ट वाक्य तय करें.
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 को इस्तेमाल करने का तरीका सीख लिया है, ताकि:
- ऑनलाइन अनुमान लगाने के लिए, एक ही वीएम पर को-होस्ट मॉडल
Vertex के अलग-अलग हिस्सों के बारे में ज़्यादा जानने के लिए, दस्तावेज़ देखें.
7. साफ़-सफ़ाई सेवा
अगर आपको मॉडल का इस्तेमाल नहीं करना है, तो आपको एंडपॉइंट से उन्हें डिप्लॉय करना होगा. एंडपॉइंट को पूरी तरह से भी मिटाया जा सकता है. ज़रूरत पड़ने पर, मॉडल को एंडपॉइंट पर फिर से डिप्लॉय किया जा सकता है.
वर्कबेंच से मैनेज की गई नोटबुक का समय, 180 मिनट तक काम न करने पर अपने-आप खत्म हो जाता है. इसलिए, आपको इंस्टेंस बंद होने की चिंता करने की ज़रूरत नहीं है. अगर आपको मैन्युअल तरीके से इंस्टेंस शट डाउन करना है, तो कंसोल के Vertex AI Workbench सेक्शन में, 'रोकें' बटन पर क्लिक करें. अगर आपको नोटबुक को पूरी तरह से मिटाना है, तो मिटाएं बटन पर क्लिक करें.
अपने Cloud Console में नेविगेशन मेन्यू का इस्तेमाल करके, स्टोरेज बकेट मिटाने के लिए स्टोरेज पर जाएं. इसके बाद, अपनी बकेट चुनें और मिटाएं पर क्लिक करें:
