Vertex AI ट्यूटोरियल: शुरुआती लोगों के लिए एक व्यापक मार्गदर्शिका

हालाँकि ज़्यादातर लोग Google को सर्च इंजन से जोड़ते हैं, लेकिन कंपनी का डेटा साइंस उद्योग में भी गहरा योगदान है। यह लगातार अत्याधुनिक प्रोडक्ट्स और समाधान देता है जिनका उद्देश्य डेटा से अधिकतम लाभ उठाना है। इन्हीं में से एक प्रोडक्ट, Vertex AI, 2021 में एंटरप्राइज़ स्तर पर मशीन लर्निंग प्रक्रिया को सरल बनाने के लिए जारी किया गया था।

इस ट्यूटोरियल में, हम Google के Vertex AI प्लेटफ़ॉर्म के साथ शुरुआत करना सीखेंगे और इसे ML लाइफ़ साइकल के व्यापक कार्यों को पूरा करने के लिए कैसे इस्तेमाल करें। अंत में हमारे पास एक डिप्लॉय किया हुआ मॉडल होगा, जिसे हम क्लासिफ़िकेशन टास्क के लिए प्रेडिक्शन जनरेट करने हेतु रिक्वेस्ट भेजने में इस्तेमाल कर सकेंगे।

Vertex AI क्या है?

एक सामान्य मशीन लर्निंग लाइफ़ साइकल में कई चरण होते हैं:

• डेटा तैयारी, इनजेशन, एक्सप्लोरेशन
• फ़ीचर इंजीनियरिंग, चयन
• मॉडल ट्रेनिंग और ट्यूनिंग
• डिप्लॉयमेंट और मॉडल मॉनिटरिंग

इन सभी चरणों और उप-चरणों के लिए अलग-अलग टूल्स और उन्हें समन्वित करने के लिए विविध विशेषज्ञों की टीम की आवश्यकता होती है।

Google Cloud का Vertex AI इस पूरी प्रक्रिया को एक ही प्लेटफ़ॉर्म में सुव्यवस्थित और एकीकृत करता है।

जहाँ बड़े स्तर के ML अनुप्रयोगों के लिए अनुभवी विशेषज्ञों की ज़रूरत होती है, वहीं Vertex AI किसी भी कौशल स्तर के उपयोगकर्ताओं को सक्षम बनाता है:

• शुरुआती के लिए AutoML: कोडिंग अनुभव की आवश्यकता नहीं। बस अपना डेटा दें, और कुछ क्लिक में AutoML आपके लिए उच्च-गुणवत्ता वाला मॉडल बना देता है। डेटा तैयारी, मॉडल बिल्डिंग, एल्गोरिथ्म चयन और हाइपरपैरामीटर ट्यूनिंग जैसी मेहनतपसंद प्रक्रियाएँ पृष्ठभूमि में हो जाती हैं।
• विशेषज्ञों के लिए कस्टम मॉडल ट्रेनिंग: आपका अनुभव ही सीमा है। अनुभवी डेटा वैज्ञानिकों और ML इंजीनियरों के लिए, Vertex AI PyTorch, TensorFlow, या XGBoost जैसे पसंदीदा फ़्रेमवर्क के साथ मॉडल ट्रेन करने की लचीलापन देता है।
• सभी के लिए डिप्लॉयमेंट: एक बार जब आपके पास AutoML या कस्टम तरीके से प्रशिक्षित मॉडल हो, तो Vertex AI उन्हें डिप्लॉय करना बेहद आसान बना देता है। आप मॉडलों को रियल-टाइम API के रूप में प्रकाशित कर अपने प्रोडक्ट्स में एकीकृत कर सकते हैं, या बड़े पैमाने के कार्यों के लिए बैच-प्रेडिक्शन का उपयोग कर सकते हैं।

इस खंड में कई चीज़ों का उल्लेख नहीं किया गया है, क्योंकि आप इस ट्यूटोरियल में अधिकांश पर स्वयं काम करेंगे।

Google Cloud Services क्या हैं?

प्लेटफ़ॉर्म का अन्वेषण शुरू करने से पहले, इसके पैरेंट — Google Cloud सेवाओं का उल्लेख करना ज़रूरी है। Google Cloud Services में क्लाउड कंप्यूटिंग समाधानों की एक विस्तृत शृंखला शामिल है, जो स्टोरेज, नेटवर्किंग, डेटाबेस, एनालिटिक्स और मशीन लर्निंग क्षमताएँ प्रदान करती हैं।

ये सेवाएँ Vertex AI के साथ समन्वय में काम करती हैं ताकि आपका मशीन लर्निंग वर्कफ़्लो एकीकृत हो सके। यहाँ वे सेवाएँ हैं जिनका अक्सर Vertex AI के साथ उपयोग होता है:

डेटा स्टोरेज और प्रबंधन

• क्लाउड स्टोरेज: आपके कच्चे डेटा के लिए केंद्रीय रिपॉज़िटरी के रूप में कार्य करता है, जिसे ट्रेनिंग और विश्लेषण के लिए Vertex AI एक्सेस कर सकता है।
• BigQuery: बड़े डेटासेट्स को स्टोर और क्वेरी करने के लिए एक शक्तिशाली डेटा वेयरहाउस, जो Vertex AI को इन-सूट ट्रेनिंग के लिए BigQuery ML इस्तेमाल करने देता है।

कम्प्यूट संसाधन

• Compute Engine: आपकी कस्टम मॉडल ट्रेनिंग ज़रूरतों के लिए विभिन्न कॉन्फ़िगरेशन वाली वर्चुअल मशीनें प्रदान करता है। संसाधन-गहन ट्रेनिंग कार्यों के लिए Vertex AI इन मशीनों से जुड़ सकता है।
• Vertex AI Pipelines: दक्षता के लिए विभिन्न कम्प्यूट संसाधनों पर जटिल ML वर्कफ़्लोज़ का समन्वय करता है।

यदि आप cloud.google.com पर जाएँ, तो Google Cloud सेवाएँ हमेशा आपके Google खाते से उपलब्ध रहती हैं। यदि आपने पहले कभी उनका उपयोग नहीं किया है, तो अपने फ्री ट्रायल के लिए “Get started for free” पर क्लिक करें।

अन्यथा, सीधे console.cloud.google.com पर जाएँ ताकि हम शुरुआत कर सकें।

Vertex AI के लिए अपना Google Cloud Console सेट करना

अस्वीकरण: यदि आप ट्यूटोरियल के साथ फ़ॉलो करना चाहते हैं, तो Vertex AI पर $25-30 खर्च के लिए तैयार रहें। हम सबसे सस्ते कॉन्फ़िगरेशन का उपयोग करेंगे।

जब आप अपना Google Cloud Console खोलते हैं, तो संभवतः आप निम्नलिखित वेलकम पेज पर पहुँचेंगे:

यह आपके वर्कस्पेस का नाम दिखाता है; मेरा ibexprogramming.com है।

सबसे पहले हम एक प्रोजेक्ट बनाएँगे। Google Cloud प्रोजेक्ट किसी विशेष कार्य के संसाधनों को प्रबंधित करने के लिए उच्च-स्तरीय संगठन इकाइयाँ होती हैं। इसे बनाने का तरीका इस GIF में देखें:

प्रोजेक्ट बन जाने के बाद, उसे चुनें ताकि पेज की टॉप बार पर यह दिखे:

अब, आपको एक बिलिंग अकाउंट बनाना होगा क्योंकि Vertex AI की सेवाएँ सक्षम करने के लिए बिलिंग जानकारी आवश्यक है। चिंता न करें — जब तक आप पेड संसाधनों का उपयोग नहीं करते, आपसे शुल्क नहीं लिया जाएगा। तो, यहाँ जाएँ https://console.cloud.google.com/billing:

यदि आपका अकाउंट पहले से नहीं है, तो “Create account” पर क्लिक करें और दिए गए निर्देशों का पालन करें। अगले भाग में हम इस बिलिंग अकाउंट को अपने प्रोजेक्ट से लिंक करेंगे।

इसके बाद, https://console.cloud.google.com/ पर वापस जाएँ और पेज के नीचे “View all products” बटन पर क्लिक करें:

अगला पेज आपके प्रोजेक्ट के लिए Google Cloud द्वारा दी जाने वाली सभी सेवाओं की सूची दिखाएगा। “Vertex AI” खोजें (Ctrl + F) और आसान पहुँच के लिए उसे अपने मेनू में पिन करें। फिर सेवा पर क्लिक करें:

यह आपको आपके Vertex AI डैशबोर्ड पर ले जाएगा। एक विंडो पॉप-अप हो सकती है जो आपसे Vertex AI API सक्षम करने के लिए कहेगी— “Enable” चुनें। यदि विंडो पॉप-अप नहीं होती है, तो आप “Enable all API permissions” बटन पर क्लिक कर वही कर सकते हैं।

अब, हम Vertex AI पर एक डेटासेट अपलोड करने के लिए तैयार हैं।

Vertex AI में डेटासेट अपलोड करना

Vertex AI में डेटासेट जोड़ने के कई तरीके हैं। इस भाग में, हम सरलता के लिए एक लोकल CSV फ़ाइल का उपयोग करेंगे।

नमूना डेटासेट डाउनलोड करें

इस लेख के लिए, हम UCI Machine Learning रिपॉज़िटरी से Dry Bean डेटासेट का उपयोग करेंगे। इसमें 13k बीन्स के इंस्टैंसेज़ और उनकी 15 संख्यात्मक मापें शामिल हैं।

कार्य यह है कि उन्हें सात प्रकार की बीन्स में वर्गीकृत किया जाए: Seker, Barbunya, Bombay, Cali, Dermosan, Horoz और Sira।

डाउनलोड करने के बाद, ZIP में मौजूद Excel फ़ाइल को अपने लोकल डायरेक्ट्री में सेव करें:

from pathlib import Path

cwd = Path.cwd()
data_path = cwd / "data" / "Dry_Bean_Dataset.xlsx"
संचालित द्वारा

फिर, हम pandas से इस फ़ाइल को पढ़ सकते हैं और इसे CSV के रूप में सेव कर सकते हैं:

import pandas as pd

beans = pd.read_excel(data_path)

beans.shape
संचालित द्वारा

(13611, 17)संचालित द्वारा

ध्यान दें कि read_excel फ़ंक्शन के लिए आपको PIP से openpyxl लाइब्रेरी इंस्टॉल करनी होगी।

बेहतरीन, हमारे पास DataFrame के रूप में डेटासेट है। चलिए इसे CSV के रूप में सेव करते हैं:

beans.to_csv(cwd / "data" / "dry_bean.csv", index=False)संचालित द्वारा

क्लाउड स्टोरेज बकेट बनाएँ

जैसा कि पहले बताया गया, हमें कच्चे डेटा को स्टोर करने के लिए Google Storage बकेट की आवश्यकता है। प्रोडक्ट के डैशबोर्ड तक जाने के लिए नीचे दिया GIF फ़ॉलो करें:

GIF दिखाता है कि स्टोरेज सेवाओं का उपयोग शुरू करने के लिए हमें बिलिंग अकाउंट लिंक करना होगा, जिसे हम पहले बनाए गए अकाउंट से करते हैं। फिर आप एक ग्लोबली यूनिक नाम के साथ बकेट बना पाएँगे:

एक यूनिक नाम मिलने पर, “Continue” पर क्लिक करें जब तक बकेट बन न जाए—आप सभी फ़ील्ड्स के लिए डिफ़ॉल्ट विकल्प चुन सकते हैं।

अब, हम पिछली सेक्शन में सेव की गई CSV फ़ाइल को इनजेस्ट करने के लिए तैयार हैं।

Vertex AI में लोकल CSV इनजेस्ट करें

अब, चलिए अपने Vertex AI डैशबोर्ड पर वापस चलते हैं और Datasets टैब देखते हैं:

यह आपको खाली मिलेगा, तो “+Create” बटन पर क्लिक करें:

डेटासेट को एक यूनिक नाम दें और टैब्युलर विकल्प चुनें:

फिर, प्लेटफ़ॉर्म आपको स्रोत विकल्प दिखाएगा। लोकल CSV फ़ाइल अपलोड करना चुनें, और Cloud Storage पाथ के लिए, अभी बनाए गए बकेट का चयन करें:

डेटासेट सफलतापूर्वक अपलोड होने के बाद, आपको “Analyze” टैब दिखेगा, जो CSV फ़ाइल के बारे में बुनियादी मेटाडेटा दिखाता है। आपको “TRAIN NEW MODEL” बटन भी दिखाई देगा, जो AutoML ट्रेनिंग जॉब लॉन्च करेगा।

हालाँकि, हम उस बटन का उपयोग नहीं करेंगे क्योंकि यह पूरी तरह से ML शुरुआती लोगों के लिए है। इसकी बजाय, हम Vertex AI Workbench का उपयोग करेंगे ताकि JupyterLab कोडिंग वातावरण और कंप्यूट संसाधनों को कॉन्फ़िगर कर सकें, जिससे AutoML और कस्टम दोनों लाइब्रेरियों को चला पाएँ।

Vertex AI Workbench में JupyterLab और Compute संसाधनों को कॉन्फ़िगर करना

क्योंकि Vertex AI एक एकीकृत प्लेटफ़ॉर्म है, यह वर्कबेंच नामक डेवलपमेंट एनवायरनमेंट भी प्रदान करता है। वर्कबेंच बनाने के लिए, इसके टैब पर जाएँ और नीचे दिए GIF में दिए निर्देशों का पालन करें:

हर वर्कबेंच के साथ JupyterLab 3 पहले से इंस्टॉल आता है। इसलिए, आपको केवल अपने बजट और ज़रूरतों के आधार पर हार्डवेयर विकल्प कॉन्फ़िगर करने हैं। चूँकि हमारे पास काफ़ी छोटा डेटासेट है, मैंने उदाहरण हेतु सबसे कमजोर इंस्टेंस चुना, जिसकी लागत लगभग ~0.12$ प्रति घंटा है (गणना तेज़ करने के लिए मैं ज़्यादा CPU कोर वाली मशीन चुनने की सलाह दूँगा)।

मैंने idle shutdown अवधि को 10 मिनट पर भी बदला ताकि यदि मैं इसे बंद करना भूल जाऊँ तो वातावरण अपने-आप बंद हो जाए।

वर्कबेंच को इनिशियलाइज़ होने में कुछ समय लगेगा। जैसे ही हो जाता है, “OPEN JUPYTERLAB” बटन दिखाई देगा, जिस पर हम क्लिक कर सकते हैं:

हम परिचित JupyterLab इंटरफ़ेस पर निर्देशित होंगे। वहाँ से, एक नया Python 3 नोटबुक बनाएँ और उसका नाम अपनी पसंद से रखें। पहली सेल में, Google Cloud services SDK google-cloud-aiplatform इंस्टॉल/अपग्रेड करें:

!pip3 install --upgrade --quiet google-cloud-aiplatform
संचालित द्वारा

फिर, आप अपने अकाउंट के अंतर्गत उपलब्ध प्रोजेक्ट्स को gcloud config list से लिस्ट कर सकते हैं:

!gcloud config list
संचालित द्वारा

[compute]
region = us-central1
[core]
account = # HIDDEN #
disable_usage_reporting = True
project = vertexai-tutorial-423010
[dataproc]
region = us-central1

Your active configuration is: [default]
संचालित द्वारा

gcloud और gsutil दोनों टर्मिनल यूटिलिटीज़ सभी वर्कबेंच में उपलब्ध हैं। ये आपको अपने Google Cloud सेवाओं को कुशलतापूर्वक प्रबंधित करने देती हैं।

प्रिंट आउटपुट से, निम्न जानकारी को Python वेरिएबल्स में सेव करें:

PROJECT_ID = 'vertexai-tutorial-423010'
BUCKET_URI = 'gs://vetex-tutorial-bucket-bex'
REGION = 'us-central1'
संचालित द्वारा

अपने BUCKET_URI को अपने बकेट नाम से बदलना न भूलें। फिर, aiplatform सबमॉड्यूल इम्पोर्ट करें और इसे इनिशियलाइज़ करें:

from google.cloud import aiplatform as ai

ai.init(project=PROJECT_ID, location=REGION, staging_bucket=BUCKET_URI)
संचालित द्वारा

aiplatform Vertex AI फीचर्स के साथ इंटरैक्ट करने के लिए एक SDK के रूप में काम करेगा।

जब आप ट्यूटोरियल पूरा कर लें या ब्रेक लें, तो अनचाहे खर्चों से बचने के लिए इंस्टेंस को STOP करना न भूलें।

Vertex AI में AutoML मॉडलों को ट्रेन और डिप्लॉय करना

अब, चलिए AutoML से एक मॉडल ट्रेन करते हैं, जो, जैसा कि पहले बताया, हमारे लिए सारी मेहनतपसंद प्रक्रिया संभालता है और दिए गए डेटासेट के लिए सर्वश्रेष्ठ मॉडल लौटाता है। इसका मतलब है कि AutoML का पूरा लाभ उठाने के लिए, आपको सुनिश्चित करना चाहिए कि आप जो डेटासेट दे रहे हैं उसकी गुणवत्ता यथासंभव उच्च हो। इसलिए, पहले से कुछ समय लेकर नए फ़ीचर्स इंजीनियर करना और आवश्यक प्रीप्रोसेसिंग करना फ़ायदेमंद रहेगा।

AutoML आंतरिक रूप से डेटासेट का प्रीप्रोसेसिंग करता है, लेकिन यह आपके डेटासेट की सभी समस्याएँ ठीक नहीं कर सकता।

हालाँकि, सरलता के लिए, इस भाग में हम बिना किसी प्रीप्रोसेसिंग या फ़ीचर इंजीनियरिंग के एक बेसलाइन AutoML मॉडल ट्रेन करेंगे।

Google Storage बकेट से डेटा लोड करना

सबसे पहले, हम अपने बकेट से CSV डेटासेट लोड करना और उस पर थोड़ा समय देकर एक्सप्लोर करना चाहेंगे। याद रखें, EDA एक महत्वपूर्ण चरण है, और आप हमारे Exploratory Data Analysis in Python कोर्स में और अधिक सीख सकते हैं!

import pandas as pd

# Path to your CSV file in GCS bucket
gcs_path = "gs://vertex-tutorial-bucket-bex/dry_bean.csv"

beans = pd.read_csv(gcs_path)

beans.head()
संचालित द्वारा

अच्छी बात यह है कि pandas GCS पाथ से फ़ाइलें डाउनलोड कर सकता है। केवल एक बात ध्यान देने की है कि ऊपर दिया कोड केवल Vertex AI वर्कबेंच में काम करता है क्योंकि वे पहले से आपके Google Cloud क्रेडेंशियल्स से ऑथेंटिकेटेड होते हैं।

Vertex AI में pandas के साथ डेटा एक्सप्लोर करना

हम डेटासेट का गहरा विश्लेषण नहीं करेंगे क्योंकि यह हमें लेख के मुख्य उद्देश्य से भटका देगा। इसलिए, हम कुछ सारांश आँकड़े और चार्ट प्रिंट करने तक सीमित रहेंगे:

beans.info()
संचालित द्वारा

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 13611 entries, 0 to 13610
Data columns (total 17 columns):
#   Column           Non-Null Count  Dtype 
---  ------           --------------  ----- 
0   Area             13611 non-null  int64 
1   Perimeter        13611 non-null  float64
2   MajorAxisLength  13611 non-null  float64
3   MinorAxisLength  13611 non-null  float64
4   AspectRation     13611 non-null  float64
5   Eccentricity     13611 non-null  float64
6   ConvexArea       13611 non-null  int64 
7   EquivDiameter    13611 non-null  float64
8   Extent           13611 non-null  float64
9   Solidity         13611 non-null  float64
10  roundness        13611 non-null  float64
11  Compactness      13611 non-null  float64
12  ShapeFactor1     13611 non-null  float64
13  ShapeFactor2     13611 non-null  float64
14  ShapeFactor3     13611 non-null  float64
15  ShapeFactor4     13611 non-null  float64
16  Class            13611 non-null  object
dtypes: float64(14), int64(2), object(1)
memory usage: 1.8+ MB
संचालित द्वारा

तो, 15 संख्यात्मक फ़ीचर्स हैं और एक टार्गेट कॉलम — Class। केवल ~13k रिकॉर्ड हैं और कोई मिसिंग वैल्यू नहीं है। इससे ट्रेनिंग काफ़ी सरल हो जाएगी।

फ़ीचर नामों को एक अलग सूची में सेव कर लेते हैं क्योंकि हमें उनकी आगे ज़रूरत पड़ सकती है:

feature_names = beans.columns.tolist()
संचालित द्वारा

अब, कुछ महत्वपूर्ण लगने वाले फ़ीचर्स का पेयर-प्लॉट बनाते हैं:

import seaborn as sns

sns.pairplot(
   beans,
   vars=["Area", "MajorAxisLength", "MinorAxisLength", "Eccentricity", "roundness"],
   hue="Class",
);
संचालित द्वारा

कुछ दिलचस्प रुझान दिखते हैं — खासकर, ऐसा लगता है कि Bombay (हरा) बीन्स अपनी भौतिक मापों के लिहाज़ से बाकियों से साफ़ अलग हैं।

चलिए एक कोरिलेशन मैट्रिक्स भी प्लॉट करते हैं:

import matplotlib.pyplot as plt

correlation = beans.corr(numeric_only=True)

# Create a square heatmap with center at 0
sns.heatmap(correlation, center=0, square=True, cmap="coolwarm", vmin=-1, vmax=1)

plt.show()
संचालित द्वारा

कुछ फ़ीचर्स लगभग पूरी तरह सह-संबंधित हैं, और यह तर्कसंगत है क्योंकि वे भौतिक मापों से जुड़े हैं। हालाँकि, कुछ फ़ीचर जोड़े ऐसे भी हैं जिनमें बहुत कम या कोई सह-संबंध नहीं है।

इस बिंदु पर, मैं आपको आगे की खोज करने और डेटासेट के बारे में कुछ प्रश्न ढूँढ़कर उनका उत्तर देने के लिए छोड़ता हूँ।

AutoML ट्रेनिंग जॉब चलाना

AutoML ट्रेनिंग जॉब शुरू करने के लिए, हमें पहले इसके साथ संगत एक डेटासेट ऑब्जेक्ट चाहिए:

ds = ai.TabularDataset.create(
   display_name="dry_bean_dataset", gcs_source=gcs_path
)
संचालित द्वारा

TabularDataset created. 
संचालित द्वारा

type(ds)संचालित द्वारा

google.cloud.aiplatform.datasets.tabular_dataset.TabularDataset
संचालित द्वारा

ds.resource_name
संचालित द्वारा

'projects/10783853768/locations/us-central1/datasets/4978116960081412096'
संचालित द्वारा

हम TabularDataset.create मेथड का उपयोग कर इसे ds के रूप में इनिशियलाइज़ करते हैं। Vertex AI इसे अपना नाम असाइन करता है, जो इसके resource_name एट्रिब्यूट से उपलब्ध है।

अब, हम ai.AutoMLTabularTrainingJob क्लास से जॉब को इनिशियलाइज़ करते हैं। इसे दो आर्ग्युमेंट चाहिए:

• जॉब के लिए एक डिस्प्ले नाम
• टास्क का उद्देश्य — इस मामले में क्लासिफ़िकेशन।

job = ai.AutoMLTabularTrainingJob(
   display_name="dry-bean-classification",
   optimization_prediction_type="classification",
)
संचालित द्वारा

अगला, हम जॉब का run मेथड चलाते हैं:

model = job.run(
   dataset=ds,
   target_column="Class",
   training_fraction_split=0.8,
   validation_fraction_split=0.1,
   test_fraction_split=0.1,
   model_display_name="baseline-classification-model",
   disable_early_stopping=False,
)
संचालित द्वारा

मेथड के पैरामीटर्स काफ़ी स्वयंस्पष्ट हैं। कोड को पूरा होने में कुछ समय लगेगा (आपकी कंप्यूट शक्ति पर निर्भर)।

यदि आप अपने डैशबोर्ड के “MODEL DEVELOPMENT > TRAINING” टैब पर जाएँ और जॉब के नाम पर क्लिक करें, तो आपको लाइव ट्रेनिंग प्रोग्रेस दिखेगा। नीचे दी गई छवि दिखाती है कि ट्रेनिंग प्रीप्रोसेसिंग स्टेज में है:

परिणाम देखना

ट्रेनिंग पूरी होने के बाद, फिर से ट्रेनिंग टैब पर जाएँ और मॉडल के नाम पर क्लिक करें। इस बार, मॉडल के साथ परफ़ॉर्मेंस मेट्रिक्स सूचीबद्ध होंगे:

जैसा कि आप देख सकते हैं, बेसलाइन मॉडल के लिए भी हमारे पास बहुत अच्छे मेट्रिक्स हैं, सभी 0.90 से ऊपर।

AutoML मॉडल को डिप्लॉय करना और प्रेडिक्शन जनरेट करना

अब हम इस model को एक लाइन कोड से डिप्लॉय कर सकते हैं:

endpoint = model.deploy(machine_type="n1-standard-4")
संचालित द्वारा

deploy मेथड को केवल एक आर्ग्युमेंट चाहिए — इंफ़रेंस चलाने के लिए मशीन का प्रकार। मैं ऊपर की लाइन वास्तव में नहीं चलाऊँगा क्योंकि डिप्लॉयमेंट तब तक अतिरिक्त लागत लाता है जब तक मॉडल ऑनलाइन रहता है।

हालाँकि, यदि आप इसे चलाते हैं, तो deploy मेथड एक Endpoint ऑब्जेक्ट लौटाता है, जिसे हम रिक्वेस्ट भेज सकते हैं:

prediction = endpoint.predict(
   [
       {
           "Area": "30099",
           "Perimeter": "638.8209999999999",
           "MajorAxisLength": "237.14191130827916",
           "MinorAxisLength": "162.3034300714102",
           "AspectRation": "1.4611022774068396",
           "Eccentricity": "0.7290928631259719",
           "ConvexArea": "30477",
           "EquivDiameter": "195.76321681302556",
           "Extent": "0.8036043251902283",
           "Solidity": "0.9875972044492568",
           "roundness": "0.9268374259664279",
           "Compactness": "0.8255108332939839",
           "ShapeFactor1": "0.007878730566074592",
           "ShapeFactor2": "0.002256976927384019",
           "ShapeFactor3": "0.6814681358857279",
           "ShapeFactor4": "0.9956946453228307",
       }
   ]
)

print(prediction)
संचालित द्वारा

इसका predict मेथड सैंपल्स की एक सूची स्वीकार करता है, जिन पर प्रेडिक्शन करना है। सैंपल्स JSON फ़ॉर्मेट में दिए जाने चाहिए।

आप डैशबोर्ड का उपयोग कर भी मॉडल डिप्लॉय कर सकते हैं। यदि आप “MODEL REGISTRY” टैब पर जाएँ, तो वहाँ मॉडल सूचीबद्ध दिखेगा। इसके नाम पर क्लिक करें और “DEPLOY & TEST” टैब चुनें:

‘DEPLOY TO ENDPOINT’ बटन पर क्लिक करने से आप एक अलग पेज पर पहुँचते हैं जहाँ आप अपनी मशीन को कॉन्फ़िगर कर मॉडल डिप्लॉय कर सकते हैं। लेकिन उससे पहले, आप डिप्लॉयमेंट बटन के नीचे दिए क्षेत्र में इसे टेस्ट कर सकते हैं:

Vertex AI में कस्टम मॉडलों को ट्रेन और डिप्लॉय करना

Vertex AI में कस्टम मॉडलों को डिप्लॉय करना AutoML मॉडलों की तुलना में ज़्यादा चुनौतीपूर्ण है और इसकी लागत भी अधिक है, क्योंकि आपके Workbench और डिप्लॉयमेंट खर्चों के अलावा कुछ Docker कंटेनर शामिल होंगे। यदि आप तैयार हैं, तो चलिए शुरू करें!

Vertex AI में कस्टम ट्रेनिंग का उच्च-स्तरीय अवलोकन

कस्टम ट्रेनिंग एक कस्टम मॉडल ट्रेनिंग स्क्रिप्ट से शुरू होती है। इस स्क्रिप्ट में हम कुछ भी कर सकते हैं, बशर्ते कि यह:

• GCS बकेट से डेटा लोड करे
• किसी ML फ़्रेमवर्क (TF, PyTorch, Scikit-learn, XGBoost) से मॉडल ट्रेन करे
• वैकल्पिक रूप से, मॉडल के हाइपरपैरामीटर्स ट्यून करे
• प्रशिक्षित या ट्यून किए गए मॉडल को कैप्चर करने के लिए GCS बकेट में सेव करे।

फिर, इस ट्रेनिंग स्क्रिप्ट को Docker कंटेनर में बदलना होता है और फिर Google Container Registry पर पुश करना होता है। वहाँ से, हम Vertex AI Python SDK या डैशबोर्ड का उपयोग कर कस्टम मॉडल ट्रेन कर सकते हैं।

ट्रेनिंग कोड के लिए डायरेक्ट्री संरचना बनाना

सबसे पहले, Google के इस कोड लैब की सिफ़ारिश के अनुसार डायरेक्ट्री संरचना बनाते हैं। अपने वर्कबेंच में, नया लॉन्चर शुरू करके टर्मिनल पर स्विच करें:

फिर, “dry-beans” नाम की एक नई डायरेक्ट्री बनाएँ और उसमें जाएँ:

$ mkdir dry-beans
$ cd dry-beans/
संचालित द्वारा

dry-beans के अंदर, trainer नाम की एक और डायरेक्ट्री बनाएँ और उसके अंदर train.py Python फ़ाइल बनाएँ:

$ mkdir trainer
$ touch trainer/train.py
संचालित द्वारा

Dockerfile बनाना

अब, एक नया Dockerfile बनाएँ:

$ touch Dockerfile
संचालित द्वारा

फ़ाइल खोलें और निम्न सामग्री पेस्ट करें:

FROM gcr.io/deeplearning-platform-release/tf2-cpu.2-6
WORKDIR /

# Copies the trainer code to the docker image.
COPY trainer /trainer

# Install XGBoost
RUN pip install xgboost==1.6.2

# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "-m", "trainer.train"]
संचालित द्वारा

यह Dockerfile TensorFlow के साथ Google Container Registry द्वारा प्रदान की गई आधिकारिक डीप लर्निंग इमेज का उपयोग करता है। फ़ाइल हमारे trainer डायरेक्ट्री को कॉपी करती है और फिर XGBoost इंस्टॉल करती है। अंत में यह हमारा Python स्क्रिप्ट चलाएगा।

ट्रेनिंग स्क्रिप्ट लिखना

स्क्रिप्ट को हमारे GCP बकेट से Dry Beans डेटासेट लोड करना चाहिए, उस पर XGBoost क्लासिफ़ायर ट्रेन करना चाहिए और मॉडल को वापस बकेट में सेव करना चाहिए। मैंने इन कार्यों को करने वाली एक सरल स्क्रिप्ट इस GitHub gist में लिखी है (स्थान बचाने के लिए यहाँ साझा नहीं कर रहा हूँ)।

gist का कोड कॉपी/पेस्ट कर train.py में डालें। फिर, टर्मिनल में वापस जाकर XGBoost इंस्टॉल करें क्योंकि यह आपके चुने हुए Workbench में पहले से इंस्टॉल नहीं आता, और स्क्रिप्ट चलाएँ:

$ pip install xgboost==1.6.2
$ python trainer/train.py
संचालित द्वारा

Docker इमेज बनाना

यदि स्क्रिप्ट बिना त्रुटियों के चलती है, तो टर्मिनल में ये दो वेरिएबल्स दर्ज करें:

$ PROJECT_ID='vertexai-tutorial-423010'  # Replace with your PROJECT_ID from earlier
$ IMAGE_URI="gcr.io/$PROJECT_ID/dry-beans:v1"  # This stays the same
संचालित द्वारा

जब हम कंटेनर बनाएँगे, तब ये वेरिएबल्स काम आएँगे, और इसके लिए यह करें:

$ docker build ./ -t $IMAGE_URI
संचालित द्वारा

बिल्ड में कुछ समय लगेगा। पूरा होने के बाद, कंटेनर चलाएँ ताकि पक्का हो जाए कि सबकुछ ठीक से चल रहा है:

$ docker run $IMAGE_URI
संचालित द्वारा

Model trained successfully!
Model uploaded successfully!
संचालित द्वारा

यदि ऊपर दिए सफलता संदेश मिलते हैं, तो कंटेनर पुश करने के लिए तैयार है:

$ docker push $IMAGE_URIसंचालित द्वारा

कस्टम ट्रेनिंग जॉब बनाना

इस बिंदु पर, ज़्यादातर काम हो चुका है। अब हम डैशबोर्ड पर स्विच कर हाल ही में पुश किए गए कंटेनर का उपयोग करके कस्टम ट्रेनिंग जॉब बना सकते हैं। “MODEL REGISTRY” टैब पर जाएँ और “CREATE” पर क्लिक करें:

ट्रेनिंग मेथड के लिए, “No managed dataset” और “Custom training” विकल्प चुनें। अगली पेन (Model details) में, मॉडल को नाम दें — dry-beans-classifier।

ट्रेनिंग कंटेनर पेन में:

कस्टम इमेज के लिए हमने जो कंटेनर पुश किया है उसे चुनें और मॉडल आउटपुट के लिए cloud-ai-platform बकेट चुनें। फिर “Compute and pricing” पेन तक पहुँचने तक Continue पर क्लिक करें:

4 CPU के साथ मानक n1 मशीन चुनें और अंत में “START TRAINING” पर क्लिक करें। फिर, अपने डैशबोर्ड के “TRAINING” टैब पर स्विच करें।

इस बिंदु पर, आपको दो में से एक चीज़ दिखेगी:

1. ट्रेनिंग फेल्ड स्टेटस
2. ट्रेनिंग इन प्रोग्रेस स्टेटस

मुझे पहला वाला मिला, तो चलिए जानें क्यों, इसके लिए मॉडल के नाम पर क्लिक करते हैं:

एरर बता रहा है कि मैंने अनुमत कस्टम ट्रेनिंग CPU की संख्या से अधिक उपयोग कर लिया। मैंने गहराई से जाँच की और जो मिला वह काफ़ी निराशाजनक था।

आम तौर पर, GCP किसी भी कम्प्यूट क्षेत्र के लिए कम से कम 20 CPU कोटा देता है, लेकिन अपनी प्रोफ़ाइल जाँचने पर मैंने पाया कि मेरा कोटा केवल 1 है। इसका मतलब था कि मैं कोई भी कस्टम ट्रेनिंग जॉब नहीं चला सकता था, क्योंकि Google द्वारा दी जाने वाली सभी मशीनों में कम से कम दो CPU होते हैं।

मैंने इस StackOverflow थ्रेड के जवाबों का उपयोग कर अपना कोटा बढ़ाने की कोशिश की, लेकिन वे काम नहीं किए। मुझे जो संदेश मिला वह यह था कि नए Vertex AI उपयोगकर्ताओं को केवल एक CPU यूनिट की अनुमति है। यदि मुझे अपना कोटा बढ़ाना है, तो मुझे सपोर्ट टिकट सबमिट करना होगा, जो कि, जैसा कि पता चला, मुफ़्त नहीं है (इसके लिए पेड सपोर्ट कॉन्ट्रैक्ट चाहिए)।

तो, यदि आप मेरी तरह बदकिस्मत हैं, तो SO थ्रेड के जवाब आज़माएँ। वे कुछ लोगों के लिए काम किए, लेकिन यदि आपके लिए काम न करें, तो आपका एकमात्र विकल्प सपोर्ट से संपर्क करना है।

पर यदि आप भाग्यशाली हैं और आपकी ट्रेनिंग पूरी हो जाती है, तो आप AutoML मॉडलों के लिए बताए गए वही चरणों से मॉडल डिप्लॉय कर पाएँगे।

निष्कर्ष

Vertex AI एक विशाल प्लेटफ़ॉर्म है जिसमें कई फ़ीचर्स हैं। इस ट्यूटोरियल में, हमने केवल सतह को छुआ है, लेकिन प्लेटफ़ॉर्म के सबसे महत्वपूर्ण बिल्डिंग ब्लॉक्स को कवर किया है। स्टोरेज बकेट्स, वर्कबेंच और ट्रेनिंग जॉब्स बनाना सीखकर, आप प्लेटफ़ॉर्म के बाकी हिस्सों को एक्सप्लोर करने के लिए अच्छी तरह तैयार होंगे।

यदि आप Google Cloud सेवाओं के बारे में और सीखना चाहते हैं, तो ये संबंधित संसाधन देखें:

• Introduction to GCP कोर्स
• Google Cloud For Data Science ट्यूटोरियल
• AWS बनाम Azure बनाम GCP सेवाओं की तुलना
• Google Gemini ट्यूटोरियल