1. खास जानकारी
इस लैब में, आपको Vertex AI का इस्तेमाल करके, पहले से ट्रेन किए गए इमेज क्लासिफ़िकेशन मॉडल से अनुमान पाने होंगे.
आपको ये सब सीखने को मिलेगा
आपको, इनके बारे में जानकारी मिलेगी:
- Vertex AI Model Registry में TensorFlow मॉडल इंपोर्ट करना
- ऑनलाइन अनुमान पाना
- TensorFlow के किसी फ़ंक्शन को अपडेट करना
Google Cloud पर इस लैब को चलाने की कुल लागत एक डॉलर है.
2. Vertex AI के बारे में जानकारी
यह लैब, Google Cloud पर उपलब्ध एआई (AI) प्रॉडक्ट के सबसे नए वर्शन का इस्तेमाल करती है. Vertex AI, Google Cloud के सभी एमएल ऑफ़र को एक साथ इंटिग्रेट करता है, ताकि डेवलपर को आसानी से डेवलपमेंट का अनुभव मिल सके. पहले, AutoML की मदद से ट्रेन किए गए मॉडल और कस्टम मॉडल को अलग-अलग सेवाओं से ऐक्सेस किया जा सकता था. नई सेवा में, एक एपीआई से नए प्रॉडक्ट और इन दोनों का इस्तेमाल किया जा सकता है. मौजूदा प्रोजेक्ट को Vertex AI पर भी माइग्रेट किया जा सकता है.
Vertex AI में कई अलग-अलग प्रॉडक्ट शामिल हैं, ताकि एंड-टू-एंड एमएल वर्कफ़्लो को बेहतर बनाया जा सके. यह लैब नीचे हाइलाइट किए गए प्रॉडक्ट पर फ़ोकस करेगी: अनुमान और वर्कबेंच
3. इस्तेमाल के उदाहरण की खास जानकारी
इस लैब में, आपको TensorFlow Hub से पहले से ट्रेन किए गए मॉडल को लेने और उसे Vertex AI पर डिप्लॉय करने का तरीका बताया जाएगा. TensorFlow हब, कई तरह की समस्या वाले डोमेन के लिए ट्रेन किए गए मॉडल का डेटा स्टोर करने की जगह है. जैसे, एम्बेड करना, टेक्स्ट जनरेट करना, बोली को लिखाई में बदलना, इमेज को अलग-अलग सेगमेंट में बांटना.
इस लैब में इस्तेमाल किया गया उदाहरण, MobileNet V1 इमेज क्लासिफ़िकेशन मॉडल है. इसे ImageNet डेटासेट पर पहले से ट्रेन किया गया है. TensorFlow Hub या इसी तरह के अन्य डीप लर्निंग रिपॉज़िटरी से, पहले से तैयार मॉडल का इस्तेमाल करके, अनुमान लगाने से जुड़े कई टास्क के लिए अच्छी क्वालिटी के एमएल मॉडल डिप्लॉय किए जा सकते हैं. इसके लिए, आपको मॉडल को ट्रेन करने की ज़रूरत नहीं पड़ती.
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 सेक्शन में, वर्कबेंच पर क्लिक करें:
अगर Notebooks API पहले से चालू नहीं है, तो उसे चालू करें.
चालू करने के बाद, मैनेज की जा रही नोटबुक पर क्लिक करें:
इसके बाद, नई नोटबुक चुनें.
अपनी नोटबुक को कोई नाम दें. इसके बाद, अनुमति में जाकर, सेवा खाता चुनें
ऐडवांस सेटिंग को चुनें.
अगर टर्मिनल की सुविधा पहले से चालू नहीं है, तो सुरक्षा में जाकर, "टर्मिनल चालू करें" को चुनें.
अन्य सभी बेहतर सेटिंग को पहले जैसा ही रहने दें.
इसके बाद, बनाएं पर क्लिक करें. इंस्टेंस को प्रोवाइड करने में कुछ मिनट लगेंगे.
इंस्टेंस बनाने के बाद, JUPYTERLAB खोलें को चुनें.
5. मॉडल रजिस्टर करना
पहला चरण: Cloud Storage में मॉडल अपलोड करना
ImagNet डेटासेट पर ट्रेन किए गए MobileNet V1 मॉडल के लिए, TensorFlow Hub पेज पर जाने के लिए, इस लिंक पर क्लिक करें.
सेव किए गए मॉडल के आर्टफ़ैक्ट डाउनलोड करने के लिए, डाउनलोड करें को चुनें.
Google Cloud Console के Cloud Storage सेक्शन में जाकर, बनाएं को चुनें
अपनी बकेट को कोई नाम दें और क्षेत्र के तौर पर us-central1 चुनें. इसके बाद, बनाएं पर क्लिक करें
बकेट में, TensorFlow hub से डाउनलोड किया गया मॉडल अपलोड करें. पक्का करें कि आपने पहले फ़ाइल को अनटैग कर लिया हो.
आपका बकेट कुछ ऐसा दिखना चाहिए:
imagenet_mobilenet_v1_050_128_classification_5/
saved_model.pb
variables/
variables.data-00000-of-00001
variables.index
दूसरा चरण: रजिस्ट्री में मॉडल इंपोर्ट करना
Cloud Console में, Vertex AI के मॉडल रजिस्ट्री सेक्शन पर जाएं.
इंपोर्ट करें को चुनें
नए मॉडल के तौर पर इंपोर्ट करें चुनें. इसके बाद, अपने मॉडल के लिए कोई नाम दें.
मॉडल सेटिंग में, पहले से बने TensorFlow के कंटेनर की जानकारी दें. इसके बाद, Cloud Storage में वह पाथ चुनें जहां आपने मॉडल आर्टफ़ैक्ट सेव किए हैं.
एक्सप्लेनेबिलिटी सेक्शन को छोड़ा जा सकता है.
इसके बाद, इंपोर्ट करें को चुनें
इंपोर्ट करने के बाद, आपको मॉडल रजिस्ट्री में अपना मॉडल दिखेगा
6. मॉडल डिप्लॉय करें
मॉडल रजिस्ट्री में, मॉडल की दाईं ओर मौजूद तीन बिंदु चुनें. इसके बाद, एंडपॉइंट पर डिप्लॉय करें पर क्लिक करें.
अपना एंडपॉइंट तय करें में नया एंडपॉइंट बनाएं चुनें और फिर अपने एंडपॉइंट को कोई नाम दें.
मॉडल सेटिंग में जाकर, कंप्यूट नोड की ज़्यादा से ज़्यादा संख्या को 1 पर सेट करें. साथ ही, मशीन टाइप को n1-standard-2 पर सेट करें और बाकी सभी सेटिंग को पहले जैसा ही रहने दें. इसके बाद, डिप्लॉय करें पर क्लिक करें.
डिप्लॉय होने के बाद, डिप्लॉयमेंट का स्टेटस Vertex AI पर डिप्लॉय किया गया में बदल जाएगा.
7. अनुमान पाना
सेट अप करने के दौरान बनाई गई Workbench नोटबुक खोलें. लॉन्चर से, TensorFlow 2 वाली नई नोटबुक बनाएं.
ज़रूरी लाइब्रेरी इंपोर्ट करने के लिए, नीचे दी गई सेल को चलाएं
from google.cloud import aiplatform
import tensorflow as tf
import numpy as np
from PIL import Image
आपने TensorFlow हब से जिस MobileNet मॉडल को डाउनलोड किया था उसे ImageNet डेटासेट पर तैयार किया गया था. MobileNet मॉडल का आउटपुट, एक संख्या होती है जो ImageNet डेटासेट में मौजूद क्लास लेबल के बराबर होती है. उस संख्या को स्ट्रिंग लेबल में अनुवाद करने के लिए, आपको इमेज लेबल डाउनलोड करने होंगे.
# Download image labels
labels_path = tf.keras.utils.get_file('ImageNetLabels.txt','https://storage.googleapis.com/download.tensorflow.org/data/ImageNetLabels.txt')
imagenet_labels = np.array(open(labels_path).read().splitlines())
एंडपॉइंट को हिट करने के लिए, आपको एंडपॉइंट रिसॉर्स तय करना होगा. {PROJECT_NUMBER} और {ENDPOINT_ID} को ज़रूर बदलें.
PROJECT_NUMBER = "{PROJECT_NUMBER}"
ENDPOINT_ID = "{ENDPOINT_ID}"
endpoint = aiplatform.Endpoint(
endpoint_name=f"projects/{PROJECT_NUMBER}/locations/us-central1/endpoints/{ENDPOINT_ID}")
आपको अपना प्रोजेक्ट नंबर, Console के होम पेज पर दिखेगा.
साथ ही, Vertex AI के एंडपॉइंट सेक्शन में एंडपॉइंट आईडी.
इसके बाद, आपको अपने एंडपॉइंट की जांच करनी होगी.
सबसे पहले, यहां दी गई इमेज डाउनलोड करें और उसे अपने इंस्टेंस पर अपलोड करें.
पीआईएल वाली इमेज खोलें. इसके बाद, उसका साइज़ बदलें और उसे 255 तक स्केल करें. ध्यान दें कि मॉडल के लिए इमेज का साइज़, मॉडल के TensorFlow हब पेज पर देखा जा सकता है.
IMAGE_PATH = "test-image.jpg"
IMAGE_SIZE = (128, 128)
im = Image.open(IMAGE_PATH)
im = im.resize(IMAGE_SIZE
im = np.array(im)/255.0
इसके बाद, NumPy डेटा को सूची में बदलें, ताकि उसे http अनुरोध के मुख्य हिस्से में भेजा जा सके.
x_test = im.astype(np.float32).tolist()
आखिर में, एंडपॉइंट को अनुमान लगाने के लिए कॉल करें और फिर उससे जुड़ा स्ट्रिंग लेबल देखें.
# make prediction request
result = endpoint.predict(instances=[x_test]).predictions
# post process result
predicted_class = tf.math.argmax(result[0], axis=-1)
string_label = imagenet_labels[predicted_class]
print(f"label ID: {predicted_class}")
print(f"string label: {string_label}")
8. [ज़रूरी नहीं] अनुमान को ऑप्टिमाइज़ करने के लिए, TF Serving का इस्तेमाल करना
ज़्यादा असली उदाहरणों के लिए, हो सकता है कि आप पहले NumPy में इमेज लोड करने के बजाय, सीधे तौर पर इमेज को एंडपॉइंट पर भेजना चाहें. यह तरीका ज़्यादा असरदार है, लेकिन आपको TensorFlow मॉडल के सर्विंग फ़ंक्शन में बदलाव करना होगा. यह बदलाव, इनपुट डेटा को उस फ़ॉर्मैट में बदलने के लिए ज़रूरी है जिसे आपका मॉडल उम्मीद करता है.
पहला चरण: विज्ञापन दिखाने की सुविधा में बदलाव करना
एक नई TensorFlow नोटबुक खोलें और ज़रूरी लाइब्रेरी इंपोर्ट करें.
from google.cloud import aiplatform
import tensorflow as tf
सेव किए गए मॉडल के आर्टफ़ैक्ट डाउनलोड करने के बजाय, इस बार आपको hub.KerasLayer का इस्तेमाल करके मॉडल को TensorFlow में लोड करना होगा. यह TensorFlow के सेव किए गए मॉडल को Keras लेयर के तौर पर रैप करता है. मॉडल बनाने के लिए, डाउनलोड किए गए टीएफ़ हब मॉडल के साथ Keras सिक्वेंशल एपीआई का इस्तेमाल लेयर के तौर पर किया जा सकता है. साथ ही, मॉडल के लिए इनपुट का साइज़ तय किया जा सकता है.
tfhub_model = tf.keras.Sequential(
[hub.KerasLayer("https://tfhub.dev/google/imagenet/mobilenet_v1_050_128/classification/5")]
)
tfhub_model.build([None, 128, 128, 3])
पहले से बनाई गई बकेट का यूआरआई तय करें.
BUCKET_URI = "gs://{YOUR_BUCKET}"
MODEL_DIR = BUCKET_URI + "/bytes_model"
ऑनलाइन अनुमान सर्वर को अनुरोध भेजने पर, वह अनुरोध एचटीटीपी सर्वर को मिलता है. एचटीटीपी सर्वर, एचटीटीपी अनुरोध के कॉन्टेंट बॉडी से अनुमान के अनुरोध को निकालता है. अनुमान लगाने के लिए निकाला गया अनुरोध, सर्विंग फ़ंक्शन को भेज दिया जाता है. Vertex AI के पहले से बने अनुमान वाले कंटेनर के लिए, अनुरोध का कॉन्टेंट tf.string के तौर पर, सर्विंग फ़ंक्शन को पास किया जाता है.
सुझाव देने वाली सेवा के लिए इमेज भेजने के लिए, आपको कंप्रेस की गई इमेज बाइट को बेस 64 में एन्कोड करना होगा. इससे नेटवर्क पर बाइनरी डेटा के ट्रांसमिट करते समय, कॉन्टेंट में बदलाव नहीं होगा.
डिप्लॉय किए गए मॉडल को इनपुट डेटा, रॉ (बिना कंप्रेस किए गए) बाइट के तौर पर चाहिए. इसलिए, आपको यह पक्का करना होगा कि Base64 में एन्कोड किया गया डेटा, रॉ बाइट (जैसे, JPEG) में वापस बदल जाए. इसके बाद, उसे डिप्लॉय किए गए मॉडल में इनपुट के तौर पर भेजने से पहले, मॉडल के इनपुट की ज़रूरी शर्तों के हिसाब से पहले से प्रोसेस कर लें.
इस समस्या को हल करने के लिए, आपको एक सर्विंग फ़ंक्शन (serving_fn) तय करना होगा और उसे प्रीप्रोसेसिंग के चरण के तौर पर मॉडल से जोड़ना होगा. आपने @tf.function डेकोरेटर जोड़ा है, ताकि सर्विंग फ़ंक्शन मौजूदा मॉडल (सीपीयू पर अपस्ट्रीम के बजाय) के साथ मर्ज हो जाए.
CONCRETE_INPUT = "numpy_inputs"
def _preprocess(bytes_input):
decoded = tf.io.decode_jpeg(bytes_input, channels=3)
decoded = tf.image.convert_image_dtype(decoded, tf.float32)
resized = tf.image.resize(decoded, size=(128, 128))
return resized
@tf.function(input_signature=[tf.TensorSpec([None], tf.string)])
def preprocess_fn(bytes_inputs):
decoded_images = tf.map_fn(
_preprocess, bytes_inputs, dtype=tf.float32, back_prop=False
)
return {
CONCRETE_INPUT: decoded_images
} # User needs to make sure the key matches model's input
@tf.function(input_signature=[tf.TensorSpec([None], tf.string)])
def serving_fn(bytes_inputs):
images = preprocess_fn(bytes_inputs)
prob = m_call(**images)
return prob
m_call = tf.function(tfhub_model.call).get_concrete_function(
[tf.TensorSpec(shape=[None, 128, 128, 3], dtype=tf.float32, name=CONCRETE_INPUT)]
)
tf.saved_model.save(tfhub_model, MODEL_DIR, signatures={"serving_default": serving_fn})
जब अनुमान के लिए डेटा को एचटीटीपी अनुरोध पैकेट के तौर पर भेजा जाता है, तो इमेज डेटा को base64 कोड में बदला जाता है. हालांकि, TensorFlow मॉडल, numpy इनपुट लेता है. आपका सर्विंग फ़ंक्शन, base64 से नंबर वाले अरे में कन्वर्ज़न करेगा.
अनुमान का अनुरोध करते समय, आपको अनुरोध को मॉडल के बजाय, सर्विंग फ़ंक्शन पर भेजना होगा. इसलिए, आपको सर्विंग फ़ंक्शन की इनपुट लेयर का नाम पता होना चाहिए. हमें यह नाम, फ़ंक्शन के हस्ताक्षर से मिल सकता है.
loaded = tf.saved_model.load(MODEL_DIR)
serving_input = list(
loaded.signatures["serving_default"].structured_input_signature[1].keys()
)[0]
print("Serving function input name:", serving_input)
दूसरा चरण: रजिस्ट्री में इंपोर्ट करना और डिप्लॉय करना
पिछले सेक्शन में, आपने यूज़र इंटरफ़ेस (यूआई) की मदद से, Vertex AI Model Registry में मॉडल इंपोर्ट करने का तरीका देखा था. इस सेक्शन में, आपको एसडीके के बजाय इस्तेमाल करने का दूसरा तरीका दिखेगा. ध्यान दें कि अगर आप चाहें, तो अब भी यहां यूज़र इंटरफ़ेस (यूआई) का इस्तेमाल किया जा सकता है.
model = aiplatform.Model.upload(
display_name="optimized-model",
artifact_uri=MODEL_DIR,
serving_container_image_uri="us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-8:latest",
)
print(model)
यूज़र इंटरफ़ेस (यूआई) के बजाय, SDK टूल का इस्तेमाल करके भी मॉडल को डिप्लॉय किया जा सकता है.
endpoint = model.deploy(
deployed_model_display_name='my-bytes-endpoint',
traffic_split={"0": 100},
machine_type="n1-standard-4",
accelerator_count=0,
min_replica_count=1,
max_replica_count=1,
)
तीसरा चरण: मॉडल की जांच करना
अब एंडपॉइंट की जांच की जा सकती है. हमने इमेज दिखाने के फ़ंक्शन में बदलाव किया है. इसलिए, इस बार इमेज को पहले NumPy में लोड करने के बजाय, सीधे तौर पर अनुरोध में (base64 कोड में) भेजा जा सकता है. इससे, Vertex AI के प्रीडिक्शन के साइज़ की सीमा के बिना, बड़ी इमेज भी भेजी जा सकेंगी.
इमेज के लेबल फिर से डाउनलोड करना
import numpy as np
labels_path = tf.keras.utils.get_file('ImageNetLabels.txt','https://storage.googleapis.com/download.tensorflow.org/data/ImageNetLabels.txt')
imagenet_labels = np.array(open(labels_path).read().splitlines())
इमेज को Base64 कोड में बदलें.
import base64
with open("test-image.jpg", "rb") as f:
data = f.read()
b64str = base64.b64encode(data).decode("utf-8")
अनुमान लगाने के लिए कॉल करें. इसमें, सर्विंग फ़ंक्शन की इनपुट लेयर का नाम बताएं. हमने इस फ़ंक्शन को पहले serving_input वैरिएबल में तय किया था.
instances = [{serving_input: {"b64": b64str}}]
# Make request
result = endpoint.predict(instances=instances).predictions
# Convert image class to string label
predicted_class = tf.math.argmax(result[0], axis=-1)
string_label = imagenet_labels[predicted_class]
print(f"label ID: {predicted_class}")
print(f"string label: {string_label}")
🎉 बधाई हो! 🎉
आपने Vertex AI को इस्तेमाल करने का तरीका जान लिया है, ताकि:
- पहले से ट्रेन किए गए मॉडल को होस्ट और डिप्लॉय करना
Vertex के अलग-अलग हिस्सों के बारे में ज़्यादा जानने के लिए, दस्तावेज़ देखें.
9. साफ़-सफ़ाई सेवा
Vertex AI Workbench की मदद से मैनेज किए जा रहे नोटबुक में, कोई गतिविधि न होने पर बंद होने की सुविधा होती है. इसलिए, हमें इंस्टेंस को बंद करने की चिंता नहीं करनी पड़ती. अगर आपको इंस्टेंस को मैन्युअल तरीके से बंद करना है, तो कंसोल के Vertex AI Workbench सेक्शन में जाकर, 'बंद करें' बटन पर क्लिक करें. अगर आपको नोटबुक को पूरी तरह से मिटाना है, तो मिटाएं बटन पर क्लिक करें.
स्टोरेज बकेट मिटाने के लिए, अपने Cloud Console में नेविगेशन मेन्यू का इस्तेमाल करके, स्टोरेज पर जाएं. इसके बाद, अपनी बकेट चुनें और 'मिटाएं' पर क्लिक करें:
