1. खास जानकारी
इस लैब में, आपको Vertex AI का इस्तेमाल करके, पहले से ट्रेन किए गए इमेज क्लासिफ़िकेशन मॉडल से अनुमान लगाने हैं.
आपको ये सब सीखने को मिलेगा
आपको, इनके बारे में जानकारी मिलेगी:
- Vertex AI Model Registry में TensorFlow मॉडल इंपोर्ट करना
- ऑनलाइन अनुमान पाना
- TensorFlow Serving फ़ंक्शन को अपडेट करना
इस लैब को Google Cloud पर चलाने की कुल लागत करीब 1 डॉलर है.
2. Vertex AI के बारे में जानकारी
इस लैब में, Google Cloud पर उपलब्ध एआई प्रॉडक्ट की नई सुविधा का इस्तेमाल किया जाता है. Vertex AI, Google Cloud के सभी एमएल प्रॉडक्ट को एक साथ इंटिग्रेट करता है, ताकि डेवलपर को बेहतर अनुभव मिल सके. पहले, AutoML और कस्टम मॉडल से ट्रेन किए गए मॉडल को अलग-अलग सेवाओं के ज़रिए ऐक्सेस किया जा सकता था. नए ऑफ़र में, इन दोनों को एक ही एपीआई में शामिल किया गया है. साथ ही, इसमें अन्य नए प्रॉडक्ट भी शामिल हैं. मौजूदा प्रोजेक्ट को भी Vertex AI पर माइग्रेट किया जा सकता है.
Vertex AI में कई अलग-अलग प्रॉडक्ट शामिल हैं, ताकि मशीन लर्निंग के वर्कफ़्लो को शुरू से लेकर आखिर तक सपोर्ट किया जा सके. इस लैब में, यहां हाइलाइट किए गए प्रॉडक्ट पर फ़ोकस किया जाएगा: अनुमान और वर्कबेंच
3. इस्तेमाल के उदाहरण के बारे में खास जानकारी
इस लैब में, आपको TensorFlow Hub से पहले से ट्रेन किए गए मॉडल को Vertex AI पर डिप्लॉय करने का तरीका बताया जाएगा. TensorFlow Hub, ट्रेन किए गए मॉडल का एक डेटा स्टोर है. इसमें अलग-अलग तरह की समस्याओं को हल करने के लिए मॉडल उपलब्ध हैं. जैसे, एम्बेडिंग, टेक्स्ट जनरेशन, स्पीच-टू-टेक्स्ट, इमेज सेगमेंटेशन वगैरह.
इस लैब में इस्तेमाल किया गया उदाहरण, 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 सेक्शन में जाकर, Workbench पर क्लिक करें:
अगर Notebooks API पहले से चालू नहीं है, तो इसे चालू करें.
चालू होने के बाद, मैनेज की गई नोटबुक पर क्लिक करें:
इसके बाद, नई नोटबुक चुनें.
अपनी नोटबुक को कोई नाम दें. इसके बाद, अनुमति में जाकर सेवा खाता चुनें
ऐडवांस सेटिंग को चुनें.
अगर सुरक्षा में जाकर "टर्मिनल चालू करें" विकल्प पहले से चालू नहीं है, तो इसे चालू करें.
अन्य सभी ऐडवांस सेटिंग को डिफ़ॉल्ट रूप से सेट रहने दें.
इसके बाद, बनाएं पर क्लिक करें. इंस्टेंस को चालू होने में कुछ मिनट लगेंगे.
इंस्टेंस बन जाने के बाद, JUPYTERLAB खोलें को चुनें.
5. मॉडल रजिस्टर करना
पहला चरण: मॉडल को Cloud Storage पर अपलोड करना
ImageNet डेटासेट पर ट्रेन किए गए 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 के Model registry सेक्शन पर जाएं.
IMPORT को चुनें
नए मॉडल के तौर पर इंपोर्ट करें को चुनें. इसके बाद, अपने मॉडल के लिए कोई नाम डालें.
मॉडल की सेटिंग में जाकर, पहले से बनाए गए सबसे नए TensorFlow कंटेनर के बारे में बताएं. इसके बाद, Cloud Storage में वह पाथ चुनें जहां आपने मॉडल आर्टफ़ैक्ट सेव किए हैं.
व्याख्या सेक्शन को छोड़ा जा सकता है.
इसके बाद, IMPORT चुनें
इंपोर्ट करने के बाद, आपको मॉडल रजिस्ट्री में अपना मॉडल दिखेगा
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 Hub से जो 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}")
आपको कंसोल के होम पेज पर अपना प्रोजेक्ट नंबर मिल सकता है.
साथ ही, Vertex AI के एंडपॉइंट सेक्शन में एंडपॉइंट आईडी.
इसके बाद, आपको अपने एंडपॉइंट की जांच करनी होगी.
सबसे पहले, यहां दी गई इमेज डाउनलोड करें और इसे अपने इंस्टेंस पर अपलोड करें.
PIL की मदद से इमेज खोलें. इसके बाद, साइज़ बदलें और 255 के हिसाब से स्केल करें. ध्यान दें कि मॉडल के लिए ज़रूरी इमेज का साइज़, मॉडल के TensorFlow Hub पेज पर देखा जा सकता है.
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 डेटा को सूची में बदलें, ताकि इसे एचटीटीपी अनुरोध के मुख्य भाग में भेजा जा सके.
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
सेव किए गए मॉडल आर्टफ़ैक्ट डाउनलोड करने के बजाय, इस बार मॉडल को TensorFlow में लोड किया जाएगा. इसके लिए, hub.KerasLayer का इस्तेमाल किया जाएगा. यह TensorFlow SavedModel को Keras लेयर के तौर पर रैप करता है. मॉडल बनाने के लिए, डाउनलोड किए गए TF Hub मॉडल को लेयर के तौर पर इस्तेमाल करके, Keras Sequential API का इस्तेमाल किया जा सकता है. साथ ही, मॉडल के लिए इनपुट शेप तय किया जा सकता है.
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 के तौर पर पास किया जाता है.
इमेज को अनुमान लगाने वाली सेवा को भेजने के लिए, आपको कंप्रेस की गई इमेज के बाइट को base 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 को numpy ऐरे में बदल देगा.
अनुमान लगाने का अनुरोध करते समय, आपको अनुरोध को मॉडल के बजाय, सर्विंग फ़ंक्शन पर भेजना होगा. इसलिए, आपको सर्विंग फ़ंक्शन के इनपुट लेयर का नाम पता होना चाहिए. हमें यह नाम, फ़ंक्शन के सिग्नेचर से मिल सकता है.
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)
यूज़र इंटरफ़ेस (यूआई) के बजाय, एसडीके का इस्तेमाल करके भी मॉडल को डिप्लॉय किया जा सकता है.
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,
)
तीसरा चरण: मॉडल की जांच करना
अब एंडपॉइंट की जांच की जा सकती है. हमने इमेज दिखाने वाले फ़ंक्शन में बदलाव किया है. इसलिए, इस बार इमेज को सीधे तौर पर (base64 एन्कोड किया गया) अनुरोध में भेजा जा सकता है. इसके लिए, पहले इमेज को NumPy में लोड करने की ज़रूरत नहीं है. इससे, Vertex AI Predictions के साइज़ की सीमा को पार किए बिना बड़ी इमेज भेजी जा सकेंगी.
इमेज के लेबल फिर से डाउनलोड करें
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 की मदद से मैनेज किए जा रहे notebook में, कुछ समय तक इस्तेमाल न होने पर बंद होने की सुविधा होती है. इसलिए, हमें इंस्टेंस को बंद करने की ज़रूरत नहीं होती. अगर आपको इंस्टेंस को मैन्युअल तरीके से बंद करना है, तो कंसोल के Vertex AI Workbench सेक्शन में जाकर, Stop बटन पर क्लिक करें. अगर आपको नोटबुक पूरी तरह से मिटानी है, तो 'मिटाएं' बटन पर क्लिक करें.
स्टोरेज बकेट को मिटाने के लिए, Cloud Console में नेविगेशन मेन्यू का इस्तेमाल करके, स्टोरेज पर जाएं. इसके बाद, अपनी बकेट चुनें और मिटाएं पर क्लिक करें:
