1. खास जानकारी
इस लैब में, आपको Vertex Pipelines पर Kubeflow Pipelines SDK टूल का इस्तेमाल करके, कस्टम मॉडल ट्रेनिंग जॉब चलाने का तरीका पता चलेगा.
आपको ये सब सीखने को मिलेगा
आपको, इनके बारे में जानकारी मिलेगी:
- स्केलेबल एमएल पाइपलाइन बनाने के लिए, Kubeflow Pipelines SDK टूल का इस्तेमाल करना
- Vertex AI के मैनेज किए गए डेटासेट का इस्तेमाल करने वाला कस्टम Scikit-learn मॉडल ट्रेनिंग जॉब बनाएं और उसे कंटेनर में डालें. यह जॉब, Vertex AI Training की मदद से पाइपलाइन में चलेगा
- Vertex Pipelines में, अनुमान लगाने वाली बैच जॉब चलाना
google_cloud_pipeline_componentsलाइब्रेरी की मदद से उपलब्ध Vertex AI सेवाओं के साथ इंटरैक्ट करने के लिए, पहले से बने कॉम्पोनेंट का इस्तेमाल करना
Google Cloud पर इस लैब को चलाने की कुल लागत 5 डॉलर है.
2. Vertex AI के बारे में जानकारी
यह लैब, Google Cloud पर मौजूद Vertex AI का इस्तेमाल करता है. यह Google Cloud पर मौजूद, एंड-टू-एंड मैनेज किया जाने वाला हमारा मशीन लर्निंग प्लैटफ़ॉर्म है. Vertex AI की मदद से, Google Cloud के सभी प्लैटफ़ॉर्म पर, Google के मशीन लर्निंग प्लैटफ़ॉर्म को आसानी से डेवलप किया जा सकता है. मॉडल को ट्रेनिंग देने और उसे डिप्लॉय करने की सेवाओं के अलावा, Vertex AI में कई तरह के MLOps प्रॉडक्ट भी शामिल हैं. इनमें Vertex Pipelines (इस लैब का फ़ोकस), मॉडल मॉनिटरिंग, Feature Store वगैरह शामिल हैं. नीचे दिए गए डायग्राम में, Vertex AI के सभी प्रॉडक्ट ऑफ़र देखे जा सकते हैं.
अगर आपका कोई सुझाव, शिकायत या राय है, तो कृपया सहायता पेज पर जाएं.
एमएल पाइपलाइन क्यों काम की हैं?
इस बारे में ज़्यादा जानने से पहले, यह समझ लें कि आपको पाइपलाइन का इस्तेमाल क्यों करना है. मान लें कि आपने एक ऐसा एमएल वर्कफ़्लो बनाया है जिसमें डेटा प्रोसेस करना, मॉडल को ट्रेनिंग देना, हाइपरपैरामीटर ट्यून करना, आकलन करना, और मॉडल को डिप्लॉय करना शामिल है. इनमें से हर चरण में अलग-अलग डिपेंडेंसी हो सकती हैं. अगर पूरे वर्कफ़्लो को एक ही तरह से मैनेज किया जाता है, तो यह मुश्किल हो सकता है. एमएल प्रोसेस को स्केल करने के दौरान, हो सकता है कि आप अपनी टीम के अन्य सदस्यों के साथ अपना एमएल वर्कफ़्लो शेयर करना चाहें, ताकि वे इसे चला सकें और कोड में योगदान दे सकें. भरोसेमंद और दोबारा बनाई जाने वाली प्रोसेस के बिना, काम करना मुश्किल हो सकता है. पाइपलाइन के साथ, आपकी एमएल प्रोसेस का हर चरण उसका अपना कंटेनर होता है. इसकी मदद से, अलग-अलग चरण बनाए जा सकते हैं. साथ ही, हर चरण के इनपुट और आउटपुट को दोबारा इस्तेमाल किए जा सकने वाले तरीके से ट्रैक किया जा सकता है. अपने Cloud एनवायरमेंट में होने वाले अन्य इवेंट के आधार पर, अपनी पाइपलाइन के रन को शेड्यूल या ट्रिगर भी किया जा सकता है. जैसे, नया ट्रेनिंग डेटा उपलब्ध होने पर, पाइपलाइन का रन शुरू करना.
खास जानकारी: पाइपलाइन की मदद से, एमएल वर्कफ़्लो को बेहतर बनाया जा सकता है और फिर से इस्तेमाल किया जा सकता है.
3. क्लाउड एनवायरमेंट का सेटअप
इस कोडलैब को चलाने के लिए, आपके पास बिलिंग की सुविधा वाला Google Cloud Platform प्रोजेक्ट होना चाहिए. प्रोजेक्ट बनाने के लिए, यहां दिए गए निर्देशों का पालन करें.
पहला चरण: Cloud Shell शुरू करना
इस लैब में, आपको Cloud Shell सेशन में काम करना है. यह एक कमांड इंटरप्रिटर है, जिसे Google के क्लाउड में चल रही वर्चुअल मशीन होस्ट करती है. इस सेक्शन को अपने कंप्यूटर पर भी आसानी से चलाया जा सकता है. हालांकि, Cloud Shell का इस्तेमाल करने पर, सभी को एक ही तरह के एनवायरमेंट में, बार-बार इस्तेमाल किए जा सकने वाले अनुभव का ऐक्सेस मिलता है. लैब के बाद, अपने कंप्यूटर पर इस सेक्शन को फिर से पब्लिश करने की कोशिश करें.
Cloud Shell चालू करें
Cloud Shell चालू करने के लिए, Cloud Console में सबसे ऊपर दाईं ओर मौजूद बटन पर क्लिक करें:
अगर आपने पहले कभी Cloud Shell का इस्तेमाल नहीं किया है, तो आपको एक इंटरमीडियरी स्क्रीन (फ़ोल्ड के नीचे) दिखेगी. इसमें Cloud Shell के बारे में बताया गया है. अगर ऐसा है, तो जारी रखें पर क्लिक करें. इसके बाद, आपको यह स्क्रीन दोबारा नहीं दिखेगी. एक बार दिखने वाली स्क्रीन कैसी दिखती है, यहां देखें:
Cloud Shell को प्रोवाइड करने और उससे कनेक्ट करने में सिर्फ़ कुछ मिनट लगेंगे.
इस वर्चुअल मशीन में, डेवलपमेंट के लिए ज़रूरी सभी टूल लोड होते हैं. यह 5 जीबी की होम डायरेक्ट्री उपलब्ध कराती है और Google Cloud में काम करती है. इससे नेटवर्क की परफ़ॉर्मेंस और पुष्टि करने की प्रोसेस बेहतर होती है. इस कोडलैब में, ज़्यादातर काम ब्राउज़र या Chromebook से किया जा सकता है.
Cloud Shell से कनेक्ट होने के बाद, आपको दिखेगा कि आपने पहले ही पुष्टि कर ली है और प्रोजेक्ट पहले से ही आपके प्रोजेक्ट आईडी पर सेट है.
पुष्टि करने के लिए, Cloud Shell में यह कमांड चलाएं:
gcloud auth list
आपको कमांड आउटपुट में कुछ ऐसा दिखेगा:
gcloud कमांड को आपके प्रोजेक्ट के बारे में पता है या नहीं, इसकी पुष्टि करने के लिए Cloud Shell में यह कमांड चलाएं:
gcloud config list project
कमांड आउटपुट
[core] project = <PROJECT_ID>
अगर ऐसा नहीं है, तो इसे इस निर्देश से सेट किया जा सकता है:
gcloud config set project <PROJECT_ID>
कमांड आउटपुट
Updated property [core/project].
Cloud Shell में कुछ एनवायरमेंट वैरिएबल होते हैं. इनमें GOOGLE_CLOUD_PROJECT भी शामिल है, जिसमें हमारे मौजूदा Cloud प्रोजेक्ट का नाम होता है. हम इस लैब में अलग-अलग जगहों पर इसका इस्तेमाल करेंगे. इसे देखने के लिए, यह तरीका अपनाएं:
echo $GOOGLE_CLOUD_PROJECT
दूसरा चरण: एपीआई चालू करना
आगे के चरणों में, आपको पता चलेगा कि इन सेवाओं की ज़रूरत कहां और क्यों है. हालांकि, फ़िलहाल अपने प्रोजेक्ट को Compute Engine, Container Registry, और Vertex AI की सेवाओं का ऐक्सेस देने के लिए, यह कमांड चलाएं:
gcloud services enable compute.googleapis.com \
containerregistry.googleapis.com \
aiplatform.googleapis.com
इससे आपको इस तरह का मैसेज दिखेगा:
Operation "operations/acf.cc11852d-40af-47ad-9d59-477a12847c9e" finished successfully.
तीसरा चरण: Cloud Storage बकेट बनाएं
Vertex AI पर ट्रेनिंग जॉब चलाने के लिए, हमें सेव की गई मॉडल एसेट को स्टोर करने के लिए स्टोरेज बकेट की ज़रूरत होगी. बकेट रीजनल होनी चाहिए. हम यहां us-central का उपयोग कर रहे हैं, लेकिन किसी अन्य क्षेत्र का उपयोग करने के लिए आपका स्वागत है (बस इसे इस पूरे लैब में बदलें). अगर आपके पास पहले से ही कोई बकेट है, तो इस चरण को छोड़ा जा सकता है.
बकेट बनाने के लिए, अपने Cloud Shell टर्मिनल में ये कमांड चलाएं:
BUCKET_NAME=gs://$GOOGLE_CLOUD_PROJECT-bucket
gsutil mb -l us-central1 $BUCKET_NAME
इसके बाद, हम अपने कंप्यूट सेवा खाते को इस बकेट का ऐक्सेस देंगे. इससे यह पक्का होगा कि Vertex Pipelines के पास इस बकेट में फ़ाइलें लिखने की ज़रूरी अनुमतियां हैं. इस अनुमति को जोड़ने के लिए, नीचे दिया गया कमांड चलाएं:
gcloud projects describe $GOOGLE_CLOUD_PROJECT > project-info.txt
PROJECT_NUM=$(cat project-info.txt | sed -nre 's:.*projectNumber\: (.*):\1:p')
SVC_ACCOUNT="${PROJECT_NUM//\'/}-compute@developer.gserviceaccount.com"
gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT --member serviceAccount:$SVC_ACCOUNT --role roles/storage.objectAdmin
चौथा चरण: Vertex AI Workbench इंस्टेंस बनाना
अपने Cloud Console के Vertex AI सेक्शन में, वर्कबेंच पर क्लिक करें:
इसके बाद, उपयोगकर्ता के मैनेज किए जा रहे नोटबुक में जाकर, नया नोटबुक पर क्लिक करें:
इसके बाद, GPU के बिना TensorFlow Enterprise 2.3 (LTS के साथ) इंस्टेंस टाइप चुनें:
डिफ़ॉल्ट विकल्पों का इस्तेमाल करें और फिर बनाएं पर क्लिक करें.
पांचवां चरण: अपना नोटबुक खोलना
इंस्टेंस बन जाने के बाद, JupyterLab खोलें को चुनें:
4. Vertex Pipelines का सेटअप
Vertex Pipelines का इस्तेमाल करने के लिए, हमें कुछ और लाइब्रेरी इंस्टॉल करनी होंगी:
- Kubeflow Pipelines: इस SDK टूल का इस्तेमाल करके, हम अपनी पाइपलाइन बनाएंगे. Vertex Pipelines, Kubeflow Pipelines या TFX, दोनों के साथ बनाई गई रनिंग पाइपलाइन के साथ काम करता है.
- Google Cloud के पाइपलाइन कॉम्पोनेंट: यह लाइब्रेरी, पहले से बने कॉम्पोनेंट उपलब्ध कराती है. इनकी मदद से, पाइपलाइन के चरणों से Vertex AI की सेवाओं के साथ आसानी से इंटरैक्ट किया जा सकता है.
पहला चरण: Python नोटबुक बनाना और लाइब्रेरी इंस्टॉल करना
सबसे पहले, अपने Notebook इंस्टेंस में लॉन्चर मेन्यू से (इसे ऐक्सेस करने के लिए, अपनी नोटबुक में सबसे ऊपर बाईं ओर मौजूद + आइकॉन पर क्लिक करें), Python 3 को चुनकर नोटबुक बनाएं:
लॉन्चर मेन्यू को ऐक्सेस करने के लिए, अपने नोटबुक इंस्टेंस के सबसे ऊपर बाईं ओर मौजूद + साइन पर क्लिक करें.
इस लैब में इस्तेमाल की जाने वाली दोनों सेवाओं को इंस्टॉल करने के लिए, पहले नोटबुक सेल में उपयोगकर्ता फ़्लैग सेट करें:
USER_FLAG = "--user"
इसके बाद, अपनी नोटबुक से यह चलाएं:
!pip3 install {USER_FLAG} google-cloud-aiplatform==1.7.0 --upgrade
!pip3 install {USER_FLAG} kfp==1.8.9 google-cloud-pipeline-components==0.2.0
इन पैकेज को इंस्टॉल करने के बाद, आपको कर्नेल को रीस्टार्ट करना होगा:
import os
if not os.getenv("IS_TESTING"):
# Automatically restart kernel after installs
import IPython
app = IPython.Application.instance()
app.kernel.do_shutdown(True)
आखिर में, देख लें कि आपने पैकेज सही तरीके से इंस्टॉल किए हैं या नहीं. KFP SDK टूल का वर्शन 1.8 या इससे ज़्यादा होना चाहिए:
!python3 -c "import kfp; print('KFP SDK version: {}'.format(kfp.__version__))"
!python3 -c "import google_cloud_pipeline_components; print('google_cloud_pipeline_components version: {}'.format(google_cloud_pipeline_components.__version__))"
दूसरा चरण: अपना प्रोजेक्ट आईडी और बकेट सेट करना
इस लैब में, आपको अपने Cloud प्रोजेक्ट आईडी और पहले बनाई गई बकेट का रेफ़रंस देना होगा. इसके बाद, हम इनमें से हर एक के लिए वैरिएबल बनाएंगे.
अगर आपको अपना प्रोजेक्ट आईडी नहीं पता है, तो इसे पाने के लिए यह तरीका अपनाएं:
import os
PROJECT_ID = ""
# Get your Google Cloud project ID from gcloud
if not os.getenv("IS_TESTING"):
shell_output=!gcloud config list --format 'value(core.project)' 2>/dev/null
PROJECT_ID = shell_output[0]
print("Project ID: ", PROJECT_ID)
अगर ऐसा नहीं है, तो इसे यहां सेट करें:
if PROJECT_ID == "" or PROJECT_ID is None:
PROJECT_ID = "your-project-id" # @param {type:"string"}
इसके बाद, बकेट का नाम स्टोर करने के लिए वैरिएबल बनाएं. अगर आपने इसे इस लैब में बनाया है, तो यह तरीका अपनाएं. ऐसा न करने पर, आपको इसे मैन्युअल तरीके से सेट करना होगा:
BUCKET_NAME="gs://" + PROJECT_ID + "-bucket"
तीसरा चरण: लाइब्रेरी इंपोर्ट करना
इस कोडलैब के दौरान हम जिन लाइब्रेरी का इस्तेमाल करेंगे उन्हें इंपोर्ट करने के लिए, यहां दिए गए कोड जोड़ें:
from kfp.v2 import compiler, dsl
from kfp.v2.dsl import pipeline
from google.cloud import aiplatform
from google_cloud_pipeline_components import aiplatform as gcc_aip
चौथा चरण: कॉन्स्टेंट तय करना
पाइपलाइन बनाने से पहले, हमें कुछ कॉन्स्टेंट वैरिएबल तय करने होंगे. PIPELINE_ROOT, Cloud Storage का वह पाथ है जहां हमारी पाइपलाइन से बनाए गए आर्टफ़ैक्ट सेव किए जाएंगे. हम यहां क्षेत्र के तौर पर us-central1 का इस्तेमाल कर रहे हैं. हालांकि, अगर आपने बकेट बनाते समय किसी दूसरे क्षेत्र का इस्तेमाल किया है, तो नीचे दिए गए कोड में REGION वैरिएबल को अपडेट करें:
PATH=%env PATH
%env PATH={PATH}:/home/jupyter/.local/bin
REGION="us-central1"
PIPELINE_ROOT = f"{BUCKET_NAME}/pipeline_root/"
PIPELINE_ROOT
ऊपर दिया गया कोड चलाने के बाद, आपको अपनी पाइपलाइन की रूट डायरेक्ट्री दिखेगी. यह Cloud Storage की वह जगह है जहां आपकी पाइपलाइन के आर्टफ़ैक्ट लिखे जाएंगे. यह gs://YOUR-BUCKET-NAME/pipeline_root/ फ़ॉर्मैट में होगा
5. कस्टम मॉडल ट्रेनिंग जॉब कॉन्फ़िगर करना
अपनी पाइपलाइन सेट अप करने से पहले, हमें अपने कस्टम मॉडल को ट्रेनिंग देने के लिए कोड लिखना होगा. मॉडल को ट्रेन करने के लिए, हम UCI मशीन लर्निंग ड्राई बीन्स डेटासेट का इस्तेमाल करेंगे. यह डेटासेट, KOKLU, M. और OZKAN, I.A. से लिया गया है. (2020), "कंप्यूटर विज़न और मशीन लर्निंग तकनीकों का इस्तेमाल करके, सूखी फ़ली की अलग-अलग कैटगरी में बांटना."कृषि में कंप्यूटर और इलेक्ट्रॉनिक्स, 174, 105507. DOI.
पाइपलाइन का पहला चरण, Vertex AI में मैनेज किया जाने वाला डेटासेट बनाएगा. इसके लिए, वह BigQuery टेबल का इस्तेमाल करेगा जिसमें इस बीन्स डेटा का एक वर्शन शामिल है. डेटासेट को हमारी ट्रेनिंग जॉब में इनपुट के तौर पर पास किया जाएगा. हमारे ट्रेनिंग कोड में, हमारे पास इस मैनेज किए जा रहे डेटासेट को ऐक्सेस करने के लिए, एनवायरमेंट वैरिएबल का ऐक्सेस होगा.
हम अपनी कस्टम ट्रेनिंग जॉब को इस तरह सेट अप करेंगे:
- हमारे डेटा में, बीन के टाइप को अलग-अलग कैटगरी में बांटने के लिए, Scikit-learn
DecisionTreeClassifierमॉडल लिखना - ट्रेनिंग कोड को Docker कंटेनर में पैकेज करें और उसे Container Registry में पुश करें
इसके बाद, हम सीधे अपनी पाइपलाइन से Vertex AI ट्रेनिंग जॉब शुरू कर पाएंगे. आइए, शुरू करें!
पहला चरण: Docker कंटेनर में अपना ट्रेनिंग कोड तय करना
अपने Notebooks इंस्टेंस में, लॉन्चर खोलें और Terminal चुनें:
इसके बाद, एक डायरेक्ट्री सेट अप करने के लिए यह तरीका अपनाएं. इसमें आपको अपना कंटेनर वाला कोड जोड़ना होगा:
mkdir traincontainer
cd traincontainer
touch Dockerfile
mkdir trainer
touch trainer/train.py
इन निर्देशों को चलाने के बाद, आपको बाईं ओर traincontainer/ नाम की एक डायरेक्ट्री दिखेगी. इसे देखने के लिए, आपको रीफ़्रेश आइकॉन पर क्लिक करना पड़ सकता है. आपको अपनी traincontainer/ डायरेक्ट्री में यह जानकारी दिखेगी:
+ Dockerfile
+ trainer/
+ train.py
अपने कोड को कंटेनर में डालने के लिए, सबसे पहले Dockerfile बनाना होगा. हम अपनी Dockerfile में, इमेज को चलाने के लिए ज़रूरी सभी निर्देश शामिल करेंगे. यह उन सभी लाइब्रेरी को इंस्टॉल करेगा जिनका हम इस्तेमाल कर रहे हैं और हमारे ट्रेनिंग कोड के लिए एंट्री पॉइंट सेट अप करेगा. आपने अभी जो Dockerfile बनाया है, उसे खोलें और इन्हें जोड़ें:
FROM gcr.io/deeplearning-platform-release/sklearn-cpu.0-23
WORKDIR /
# Copies the trainer code to the docker image.
COPY trainer /trainer
RUN pip install sklearn google-cloud-bigquery joblib pandas google-cloud-storage
# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "-m", "trainer.train"]
नोटबुक इंस्टेंस में फ़ाइलों में बदलाव करते समय उन्हें सेव करने के लिए, ctrl+s का इस्तेमाल किया जा सकता है.
इसके बाद, train.py फ़ाइल खोलें. यहां हम अपना ट्रेनिंग कोड जोड़ेंगे. नीचे दिए गए कोड को train.py में कॉपी करें. यह हमारे मैनेज किए जा रहे डेटासेट से डेटा को वापस लाता है, उसे Pandas DataFrame में डालता है, Scikit-learn मॉडल को ट्रेन करता है, और ट्रेन किए गए मॉडल को Cloud Storage में अपलोड करता है:
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import roc_curve
from sklearn.model_selection import train_test_split
from google.cloud import bigquery
from google.cloud import storage
from joblib import dump
import os
import pandas as pd
bqclient = bigquery.Client()
storage_client = storage.Client()
def download_table(bq_table_uri: str):
prefix = "bq://"
if bq_table_uri.startswith(prefix):
bq_table_uri = bq_table_uri[len(prefix):]
table = bigquery.TableReference.from_string(bq_table_uri)
rows = bqclient.list_rows(
table,
)
return rows.to_dataframe(create_bqstorage_client=False)
# These environment variables are from Vertex AI managed datasets
training_data_uri = os.environ["AIP_TRAINING_DATA_URI"]
test_data_uri = os.environ["AIP_TEST_DATA_URI"]
# Download data into Pandas DataFrames, split into train / test
df = download_table(training_data_uri)
test_df = download_table(test_data_uri)
labels = df.pop("Class").tolist()
data = df.values.tolist()
test_labels = test_df.pop("Class").tolist()
test_data = test_df.values.tolist()
# Define and train the Scikit model
skmodel = DecisionTreeClassifier()
skmodel.fit(data, labels)
score = skmodel.score(test_data, test_labels)
print('accuracy is:',score)
# Save the model to a local file
dump(skmodel, "model.joblib")
# Upload the saved model file to GCS
bucket = storage_client.get_bucket("YOUR_GCS_BUCKET")
model_directory = os.environ["AIP_MODEL_DIR"]
storage_path = os.path.join(model_directory, "model.joblib")
blob = storage.blob.Blob.from_string(storage_path, client=storage_client)
blob.upload_from_filename("model.joblib")
इसके बाद, अपनी नोटबुक पर वापस जाएं और ऊपर दी गई स्क्रिप्ट से YOUR_GCS_BUCKET को अपने Cloud Storage बकेट के नाम से बदलने के लिए, यह तरीका अपनाएं:
BUCKET = BUCKET_NAME[5:] # Trim the 'gs://' before adding to train script
!sed -i -r 's@YOUR_GCS_BUCKET@'"$BUCKET"'@' traincontainer/trainer/train.py
आप चाहें, तो इसे मैन्युअल तरीके से भी किया जा सकता है. अगर ऐसा है, तो स्क्रिप्ट अपडेट करते समय, अपनी बकेट के नाम में gs:// शामिल न करें.
अब हमारा ट्रेनिंग कोड, Docker कंटेनर में है और हम क्लाउड में ट्रेनिंग चलाने के लिए तैयार हैं.
दूसरा चरण: कंटेनर को Container Registry में पुश करना
ट्रेनिंग कोड पूरा होने के बाद, हम इसे Google Container Registry में पॉइंट करने के लिए तैयार हैं. बाद में, जब हम अपनी पाइपलाइन के ट्रेनिंग कॉम्पोनेंट को कॉन्फ़िगर करेंगे, तो हम Vertex Pipelines को इस कंटेनर पर ले जाएंगे.
अपने टर्मिनल पर वापस जाएं और traincontainer/ डायरेक्ट्री के रूट से, Container Registry पर अपनी कंटेनर इमेज के यूआरआई के साथ वैरिएबल तय करें.
PROJECT_ID=$(gcloud config get-value project)
IMAGE_URI="gcr.io/$PROJECT_ID/scikit:v1"
इसके बाद, अपना कंटेनर बनाने के लिए, यह तरीका अपनाएं:
docker build ./ -t $IMAGE_URI
आखिर में, कंटेनर को Container Registry में पुश करें:
docker push $IMAGE_URI
अपने Cloud Console के कंटेनर रजिस्ट्री सेक्शन पर जाकर देखें कि आपका कंटेनर वहां मौजूद है या नहीं. यह कुछ-कुछ ऐसा दिखाई देगा:
6. एक साथ कई अनुमान लगाने वाली जॉब कॉन्फ़िगर करना
हमारी पाइपलाइन के आखिरी चरण में बैच अनुमान का काम किया जाएगा. इसके लिए, हमें Cloud Storage में एक CSV फ़ाइल देनी होगी. इसमें वे उदाहरण शामिल होंगे जिन पर आपको सुझाव दिखाने हैं. हम अपनी नोटबुक में यह CSV फ़ाइल बनाएंगे और gsutil कमांड-लाइन टूल का इस्तेमाल करके, इसे Cloud Storage में कॉपी करेंगे.
एक साथ कई अनुमान के उदाहरणों को Cloud Storage में कॉपी करना
यहां दी गई फ़ाइल में, हमारे बीन्स डेटासेट की हर क्लास के तीन उदाहरण दिए गए हैं. यहां दिए गए उदाहरण में Class कॉलम शामिल नहीं है, क्योंकि हमारा मॉडल इसी कॉलम के लिए अनुमान लगाएगा. अपनी नोटबुक में स्थानीय तौर पर यह CSV फ़ाइल बनाने के लिए, यह तरीका अपनाएं:
%%writefile batch_examples.csv
Area,Perimeter,MajorAxisLength,MinorAxisLength,AspectRation,Eccentricity,ConvexArea,EquivDiameter,Extent,Solidity,roundness,Compactness,ShapeFactor1,ShapeFactor2,ShapeFactor3,ShapeFactor4
23288,558.113,207.567738,143.085693,1.450653336,0.7244336162,23545,172.1952453,0.8045881703,0.9890847314,0.9395021523,0.8295857874,0.008913077034,0.002604069884,0.6882125787,0.9983578734
23689,575.638,205.9678003,146.7475015,1.403552348,0.7016945718,24018,173.6714472,0.7652721693,0.9863019402,0.8983750474,0.8431970773,0.00869465998,0.002711119968,0.7109813112,0.9978994889
23727,559.503,189.7993849,159.3717704,1.190922235,0.5430731512,24021,173.8106863,0.8037601626,0.9877607094,0.952462433,0.9157600082,0.007999299741,0.003470231343,0.8386163926,0.9987269085
31158,641.105,212.0669751,187.1929601,1.132879009,0.4699241567,31474,199.1773023,0.7813134733,0.989959967,0.9526231013,0.9392188582,0.0068061806,0.003267009878,0.8821320637,0.9993488983
32514,649.012,221.4454899,187.1344232,1.183349841,0.5346736437,32843,203.4652564,0.7849831,0.9899826447,0.9700068737,0.9188051492,0.00681077351,0.002994124691,0.8442029022,0.9989873701
33078,659.456,235.5600775,178.9312328,1.316483846,0.6503915309,33333,205.2223615,0.7877214708,0.9923499235,0.9558229607,0.8712102818,0.007121351881,0.002530662194,0.7590073551,0.9992209221
33680,683.09,256.203255,167.9334938,1.525623324,0.7552213942,34019,207.081404,0.80680321,0.9900349805,0.9070392732,0.8082699962,0.007606985006,0.002002710402,0.6533003868,0.9966903078
33954,716.75,277.3684803,156.3563259,1.773951126,0.825970469,34420,207.9220419,0.7994819873,0.9864613597,0.8305492781,0.7496238998,0.008168948587,0.001591181142,0.5619359911,0.996846984
36322,719.437,272.0582306,170.8914975,1.591993952,0.7780978465,36717,215.0502424,0.7718560075,0.9892420405,0.8818487005,0.7904566678,0.007490177594,0.001803782407,0.6248217437,0.9947124371
36675,742.917,285.8908964,166.8819538,1.713132487,0.8119506999,37613,216.0927123,0.7788277766,0.9750618137,0.8350248381,0.7558572692,0.0077952528,0.001569528272,0.5713202115,0.9787472145
37454,772.679,297.6274753,162.1493177,1.835514817,0.8385619338,38113,218.3756257,0.8016695205,0.9827093118,0.7883332637,0.7337213257,0.007946480356,0.001420623993,0.5383469838,0.9881438654
37789,766.378,313.5680678,154.3409867,2.031657789,0.8704771226,38251,219.3500608,0.7805870567,0.9879218844,0.8085170916,0.6995293312,0.008297866252,0.001225659709,0.4893412853,0.9941740339
47883,873.536,327.9986493,186.5201272,1.758516115,0.822571799,48753,246.9140116,0.7584464543,0.9821549443,0.7885506623,0.7527897207,0.006850002074,0.00135695419,0.5666923636,0.9965376533
49777,861.277,300.7570338,211.6168613,1.42123379,0.7105823885,50590,251.7499649,0.8019106536,0.9839296304,0.843243269,0.8370542883,0.00604208839,0.001829706116,0.7006598815,0.9958014989
49882,891.505,357.1890036,179.8346914,1.986207449,0.8640114945,51042,252.0153467,0.7260210171,0.9772736178,0.7886896753,0.7055518063,0.007160679276,0.001094585314,0.4978033513,0.9887407248
53249,919.923,325.3866286,208.9174205,1.557489212,0.7666552108,54195,260.3818974,0.6966846347,0.9825445152,0.7907120655,0.8002231025,0.00611066177,0.001545654241,0.6403570138,0.9973491406
61129,964.969,369.3481688,210.9473449,1.750902193,0.8208567513,61796,278.9836198,0.7501135067,0.9892064211,0.8249553283,0.7553404711,0.006042110436,0.001213219664,0.5705392272,0.9989583843
61918,960.372,353.1381442,224.0962377,1.575832543,0.7728529173,62627,280.7782864,0.7539207091,0.9886790043,0.8436218213,0.7950947556,0.005703319619,0.00140599258,0.6321756704,0.9962029945
141953,1402.05,524.2311633,346.3974998,1.513380332,0.7505863011,143704,425.1354762,0.7147107987,0.9878152313,0.9074598849,0.8109694843,0.003692991084,0.0009853172185,0.6576715044,0.9953071199
145285,1440.991,524.9567463,353.0769977,1.486805285,0.7400216694,146709,430.0960442,0.7860466375,0.9902937107,0.8792413513,0.8192980608,0.003613289371,0.001004269363,0.6712493125,0.9980170255
146153,1476.383,526.1933264,356.528288,1.475881001,0.7354662103,149267,431.3789276,0.7319360978,0.9791380546,0.8425962592,0.8198107159,0.003600290972,0.001003163512,0.6720896099,0.991924286
इसके बाद, फ़ाइल को अपने Cloud Storage बकेट में कॉपी करें:
!gsutil cp batch_examples.csv $BUCKET_NAME
हम अगले चरण में, अपनी पाइपलाइन तय करते समय इस फ़ाइल का रेफ़रंस देंगे.
7. पहले से बने कॉम्पोनेंट की मदद से पाइपलाइन बनाना
अब हमारा ट्रेनिंग कोड क्लाउड में है. इसलिए, हम इसे अपनी पाइपलाइन से कॉल करने के लिए तैयार हैं. हम जिस पाइपलाइन के बारे में बताएंगे वह पहले से इंस्टॉल की गई google_cloud_pipeline_components लाइब्रेरी के तीन पहले से बने कॉम्पोनेंट का इस्तेमाल करेगी. पहले से तय किए गए ये कॉम्पोनेंट, हमारी पाइपलाइन को सेट अप करने के लिए लिखे जाने वाले कोड को आसान बनाते हैं. साथ ही, इनकी मदद से मॉडल को ट्रेनिंग देने और एक साथ कई अनुमान लगाने जैसी Vertex AI की सेवाओं का इस्तेमाल किया जा सकता है.
तीन चरणों वाली हमारी पाइपलाइन का काम यह होगा:
- Vertex AI में मैनेज किया जा रहा डेटासेट बनाएं
- हमारे सेट अप किए गए कस्टम कंटेनर का इस्तेमाल करके, Vertex AI पर ट्रेनिंग जॉब चलाना
- हमारे ट्रेन किए गए Scikit-learn क्लासिफ़िकेशन मॉडल पर, एक साथ कई अनुमान लगाने वाली जॉब चलाना
पहला चरण: हमारी पाइपलाइन तय करना
हम पहले से बने कॉम्पोनेंट का इस्तेमाल कर रहे हैं. इसलिए, हम अपनी पूरी पाइपलाइन को पाइपलाइन डेफ़िनिशन में सेट अप कर सकते हैं. किसी नोटबुक सेल में ये जोड़ें:
@pipeline(name="automl-beans-custom",
pipeline_root=PIPELINE_ROOT)
def pipeline(
bq_source: str = "bq://sara-vertex-demos.beans_demo.large_dataset",
bucket: str = BUCKET_NAME,
project: str = PROJECT_ID,
gcp_region: str = REGION,
bq_dest: str = "",
container_uri: str = "",
batch_destination: str = ""
):
dataset_create_op = gcc_aip.TabularDatasetCreateOp(
display_name="tabular-beans-dataset",
bq_source=bq_source,
project=project,
location=gcp_region
)
training_op = gcc_aip.CustomContainerTrainingJobRunOp(
display_name="pipeline-beans-custom-train",
container_uri=container_uri,
project=project,
location=gcp_region,
dataset=dataset_create_op.outputs["dataset"],
staging_bucket=bucket,
training_fraction_split=0.8,
validation_fraction_split=0.1,
test_fraction_split=0.1,
bigquery_destination=bq_dest,
model_serving_container_image_uri="us-docker.pkg.dev/vertex-ai/prediction/sklearn-cpu.0-24:latest",
model_display_name="scikit-beans-model-pipeline",
machine_type="n1-standard-4",
)
batch_predict_op = gcc_aip.ModelBatchPredictOp(
project=project,
location=gcp_region,
job_display_name="beans-batch-predict",
model=training_op.outputs["model"],
gcs_source_uris=["{0}/batch_examples.csv".format(BUCKET_NAME)],
instances_format="csv",
gcs_destination_output_uri_prefix=batch_destination,
machine_type="n1-standard-4"
)
दूसरा चरण: पाइपलाइन को कंपाइल और चलाना
अपनी पाइपलाइन निर्धारित होने के बाद, आप उसे कंपाइल करने के लिए तैयार हैं. इससे एक JSON फ़ाइल जनरेट होगी. इसका इस्तेमाल, पाइपलाइन चलाने के लिए किया जाएगा:
compiler.Compiler().compile(
pipeline_func=pipeline, package_path="custom_train_pipeline.json"
)
इसके बाद, TIMESTAMP वैरिएबल बनाएं. हम इसका इस्तेमाल अपने जॉब आईडी में करेंगे:
from datetime import datetime
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
इसके बाद, कुछ प्रोजेक्ट के खास पैरामीटर पास करके, पाइपलाइन जॉब तय करें:
pipeline_job = aiplatform.PipelineJob(
display_name="custom-train-pipeline",
template_path="custom_train_pipeline.json",
job_id="custom-train-pipeline-{0}".format(TIMESTAMP),
parameter_values={
"project": PROJECT_ID,
"bucket": BUCKET_NAME,
"bq_dest": "bq://{0}".format(PROJECT_ID),
"container_uri": "gcr.io/{0}/scikit:v1".format(PROJECT_ID),
"batch_destination": "{0}/batchpredresults".format(BUCKET_NAME)
},
enable_caching=True,
)
आखिर में, नई पाइपलाइन एक्सीक्यूशन बनाने के लिए जॉब चलाएं:
pipeline_job.submit()
इस सेल को चलाने के बाद, आपको अपने कंसोल में रन की गई पाइपलाइन देखने के लिए, लिंक के साथ लॉग दिखेंगे:
उस लिंक पर जाएं. इसे पाइपलाइन डैशबोर्ड खोलकर भी ऐक्सेस किया जा सकता है. पूरी होने के बाद, आपकी पाइपलाइन कुछ इस तरह दिखेगी:
इस पाइपलाइन को चलने में 5 से 10 मिनट लगेंगे. हालांकि, इसके पूरा होने से पहले ही अगले चरण पर जाया जा सकता है. इसके बाद, आपको इनमें से हर चरण में क्या हो रहा है, इस बारे में ज़्यादा जानकारी मिलेगी.
8. अपनी पाइपलाइन के एक्ज़ीक्यूशन के बारे में समझना
आइए, पाइपलाइन के तीनों चरणों के बारे में ज़्यादा जानते हैं.
पाइपलाइन का पहला चरण: मैनेज किया जा सकने वाला डेटासेट बनाना
हमारी पाइपलाइन के पहले चरण में, Vertex AI में मैनेज किया जाने वाला डेटासेट बनाया जाता है. अगर आपने अपने कंसोल के 'पाइपलाइन' सेक्शन में, नीचे दिए गए डेटासेट के लिंक पर क्लिक किया है, तो:
आपको Vertex AI में अपना डेटासेट दिखेगा. इसमें BigQuery में मौजूद डेटा सोर्स का लिंक और आपके डेटासेट के अलग-अलग कॉलम की जानकारी शामिल होगी. Vertex AI में मैनेज किया जाने वाला डेटासेट अपलोड करने के बाद, इसका इस्तेमाल AutoML या कस्टम मॉडल को ट्रेन करने के लिए किया जा सकता है.
मैनेज किए जा रहे डेटासेट का इस्तेमाल करने वाले कस्टम मॉडल जॉब के लिए, Vertex AI आपकी ट्रेनिंग जॉब के लिए खास एनवायरमेंट वैरिएबल पास करता है. साथ ही, आपके डेटा को ट्रेन और टेस्ट सेट में बांटने का काम भी करता है. हम अपने अगले चरण में इसका इस्तेमाल करेंगे.
पाइपलाइन का दूसरा चरण: Vertex AI Training में मॉडल को ट्रेनिंग देना
कस्टम ट्रेनिंग जॉब के चलने के दौरान, सीधे Vertex Pipelines कंसोल में लॉग देखने के लिए क्लिक करें:
Vertex AI के ट्रेनिंग डैशबोर्ड में भी कस्टम ट्रेनिंग जॉब की जानकारी देखी जा सकती है. ट्रेनिंग जॉब पूरी होने के बाद, Vertex AI में एक मॉडल रिसॉर्स बन जाएगा. इसके बाद, हम इस मॉडल को ऑनलाइन अनुमान के लिए एंडपॉइंट पर डिप्लॉय कर सकते हैं या एक साथ कई अनुमान लगाने वाली जॉब बना सकते हैं. हम ऐसा, पाइपलाइन के अगले चरण में करेंगे.
तीसरा चरण: हमारे मॉडल पर, अनुमान लगाने के लिए एक साथ कई डेटा डालने की प्रोसेस चलाना
आखिर में, हमारी पाइपलाइन में उन उदाहरणों के सुझाव मिलेंगे जिन्हें हमने CSV फ़ाइल से पास किया है. बैच के लिए अनुमान लगाने का काम पूरा हो जाने पर Vertex AI, Cloud Storage में बताई गई जगह के लिए CSV फ़ाइल तैयार करेगा. जब यह पाइपलाइन चरण चलना शुरू हो जाता है, तो बनाई गई जॉब देखने के लिए, अपने Vertex AI कंसोल के बैच में अनुमान सेक्शन पर जाएं.
अनुमान पूरा होने के बाद, उस पर क्लिक करके, एक साथ किए गए अनुमान का Cloud Storage यूआरएल देखें:
उस लिंक पर क्लिक करके, Cloud Storage की डायरेक्ट्री पर जाएं. यहां आपको अनुमान के नतीजे मिलेंगे. इसके बाद, prediction.results फ़ाइलों में से किसी एक को डाउनलोड करने के लिए क्लिक करें. फ़ाइल में आपको कुछ इस तरह की पंक्तियां दिखेंगी:
{"instance": [33954.0, 716.75, 277.3684803, 156.3563259, 1.773951126, 0.825970469, 34420.0, 207.9220419, 0.7994819873, 0.9864613597, 0.8305492781, 0.7496238998, 0.008168948587, 0.001591181142, 0.5619359911, 0.996846984], "prediction": "HOROZ"}
इसमें किसी खास इंस्टेंस के लिए, सुविधा की वैल्यू के साथ-साथ वह क्लास भी शामिल होती है जिसका अनुमान हमारे मॉडल ने लगाया है. इस उदाहरण के लिए, हमारा मॉडल यह अनुमान लगाता है कि यह "HOROZ" बीन है.
इसके साथ ही, आपने लैब खत्म कर लिया है!
🎉 बधाई हो! 🎉
आपने Vertex AI का इस्तेमाल करके, ये काम करने का तरीका जाना है:
- Kubeflow Pipelines SDK टूल का इस्तेमाल करके, कस्टम कॉम्पोनेंट की मदद से एंड-टू-एंड पाइपलाइन बनाएं
- Vertex Pipelines पर अपनी पाइपलाइन चलाएं और SDK टूल की मदद से, पाइपलाइन चलाएं
- कंसोल में, Vertex Pipelines ग्राफ़ देखें और उसका विश्लेषण करें
- अपनी पाइपलाइन में Vertex AI की सेवाएं जोड़ने के लिए, पहले से बने पाइपलाइन कॉम्पोनेंट का इस्तेमाल करना
- बार-बार होने वाले पाइपलाइन जॉब शेड्यूल करना
Vertex के अलग-अलग हिस्सों के बारे में ज़्यादा जानने के लिए, दस्तावेज़ देखें.
9. साफ़-सफ़ाई सेवा
हमारा सुझाव है कि इस लैब में बनाए गए संसाधनों को मिटा दें, ताकि आपसे कोई शुल्क न लिया जाए.
पहला चरण: Notebooks इंस्टेंस को रोकना या मिटाना
अगर आपको इस लैब में बनाई गई नोटबुक का इस्तेमाल जारी रखना है, तो हमारा सुझाव है कि इस्तेमाल में न होने पर उसे बंद कर दें. अपने Cloud Console में Notebook के यूज़र इंटरफ़ेस (यूआई) से, नोटबुक चुनें और फिर बंद करें चुनें. अगर आपको इंस्टेंस को पूरी तरह से मिटाना है, तो मिटाएं को चुनें:
दूसरा चरण: Cloud Storage बकेट को मिटाना
स्टोरेज बकेट मिटाने के लिए, अपने Cloud Console में नेविगेशन मेन्यू का इस्तेमाल करके, स्टोरेज पर जाएं. इसके बाद, अपनी बकेट चुनें और 'मिटाएं' पर क्लिक करें:
