1. खास जानकारी
इस लैब में, आपको Vertex Pipelines पर Kubeflow Pipelines SDK का इस्तेमाल करके, कस्टम मॉडल ट्रेनिंग जॉब चलाने का तरीका बताया जाएगा.
आपको ये सब सीखने को मिलेगा
आपको, इनके बारे में जानकारी मिलेगी:
- स्केल की जा सकने वाली एमएल पाइपलाइन बनाने के लिए, Kubeflow Pipelines SDK का इस्तेमाल करना
- Vertex AI मैनेज किए गए डेटासेट का इस्तेमाल करके, Scikit-learn मॉडल को ट्रेनिंग देने का कस्टम जॉब बनाएं और उसे कंटेनर में रखें. यह जॉब, पाइपलाइन में Vertex AI Training पर चलेगा
- Vertex Pipelines में बैच के अनुमान का काम चलाना
- Vertex AI की सेवाओं के साथ इंटरैक्ट करने के लिए, पहले से बनाए गए कॉम्पोनेंट का इस्तेमाल करें. ये कॉम्पोनेंट,
google_cloud_pipeline_componentsलाइब्रेरी के ज़रिए उपलब्ध कराए जाते हैं
Google Cloud पर इस लैब को चलाने की कुल लागत करीब 500 रुपये है.
2. Vertex AI के बारे में जानकारी
इस लैब में Vertex AI का इस्तेमाल किया गया है. यह Google Cloud पर मौजूद, मैनेज किया गया एंड-टू-एंड एमएल प्लैटफ़ॉर्म है. Vertex AI, Google Cloud के सभी एमएल ऑफ़र को इंटिग्रेट करता है, ताकि आपको डेवलपमेंट का बेहतर अनुभव मिल सके. मॉडल ट्रेनिंग और डिप्लॉयमेंट की सेवाओं के अलावा, Vertex AI में कई MLOps प्रॉडक्ट भी शामिल हैं. इनमें Vertex Pipelines (इस लैब का मुख्य विषय), मॉडल मॉनिटरिंग, Feature Store वगैरह शामिल हैं. नीचे दिए गए डायग्राम में, Vertex AI के सभी प्रॉडक्ट ऑफ़रिंग देखी जा सकती हैं.
अगर आपको कोई सुझाव देना है या शिकायत करनी है, तो कृपया सहायता पेज पर जाएं.
मशीन लर्निंग पाइपलाइन क्यों काम की होती हैं?
इससे पहले कि हम आगे बढ़ें, आइए पहले यह समझते हैं कि आपको पाइपलाइन का इस्तेमाल क्यों करना चाहिए. मान लें कि आपको एक ऐसा एमएल वर्कफ़्लो बनाना है जिसमें डेटा को प्रोसेस करना, मॉडल को ट्रेन करना, हाइपरपैरामीटर ट्यूनिंग, आकलन, और मॉडल डिप्लॉयमेंट शामिल हो. इनमें से हर चरण की अलग-अलग डिपेंडेंसी हो सकती हैं. अगर पूरे वर्कफ़्लो को एक ही यूनिट के तौर पर माना जाता है, तो यह मुश्किल हो सकता है. एमएल प्रोसेस को बड़ा करने के लिए, आपको अपनी टीम के अन्य सदस्यों के साथ एमएल वर्कफ़्लो शेयर करना पड़ सकता है. इससे वे इसे चला पाएंगे और कोड में योगदान दे पाएंगे. भरोसेमंद और दोहराई जा सकने वाली प्रोसेस के बिना, यह मुश्किल हो सकता है. पाइपलाइन की मदद से, एमएल प्रोसेस का हर चरण एक अलग कंटेनर होता है. इससे, चरणों को अलग-अलग तरीके से डेवलप किया जा सकता है. साथ ही, हर चरण के इनपुट और आउटपुट को इस तरह से ट्रैक किया जा सकता है कि उसे दोहराया जा सके. आपके पास Cloud एनवायरमेंट में मौजूद अन्य इवेंट के आधार पर, अपनी पाइपलाइन के रन को शेड्यूल करने या ट्रिगर करने का विकल्प भी होता है. जैसे, नया ट्रेनिंग डेटा उपलब्ध होने पर पाइपलाइन रन शुरू करना.
खास जानकारी: पाइपलाइन की मदद से, एमएल वर्कफ़्लो को बेहतर बनाया और फिर से बनाया जा सकता है.
3. क्लाउड एनवायरमेंट सेटअप करना
इस कोडलैब को चलाने के लिए, आपके पास बिलिंग की सुविधा वाला Google Cloud Platform प्रोजेक्ट होना चाहिए. प्रोजेक्ट बनाने के लिए, यहां दिए गए निर्देशों का पालन करें.
पहला चरण: Cloud Shell शुरू करना
इस लैब में, आपको Cloud Shell सेशन में काम करना होगा. यह एक कमांड इंटरप्रेटर है, जिसे Google के क्लाउड में चल रही वर्चुअल मशीन होस्ट करती है. इस सेक्शन को अपने कंप्यूटर पर भी आसानी से चलाया जा सकता है. हालांकि, Cloud Shell का इस्तेमाल करने से, सभी लोगों को एक जैसे एनवायरमेंट में एक जैसा अनुभव मिलता है. लैब के बाद, अपने कंप्यूटर पर इस सेक्शन को फिर से आज़माया जा सकता है.
Cloud Shell चालू करें
Cloud Console में सबसे ऊपर दाईं ओर, Cloud Shell चालू करें के लिए, नीचे दिए गए बटन पर क्लिक करें:
अगर आपने पहले कभी 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 का इस्तेमाल कर रहे हैं. हालांकि, आपके पास किसी दूसरे क्षेत्र का इस्तेमाल करने का विकल्प है. इसके लिए, आपको इस लैब में मौजूद 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 सेक्शन में जाकर, Workbench पर क्लिक करें:
इसके बाद, उपयोगकर्ता के मैनेज किए गए नोटबुक में जाकर, नई नोटबुक पर क्लिक करें:
इसके बाद, GPU के बिना TensorFlow Enterprise 2.3 (with LTS) इंस्टेंस टाइप चुनें:
डिफ़ॉल्ट विकल्पों का इस्तेमाल करें. इसके बाद, बनाएं पर क्लिक करें.
पांचवां चरण: अपनी नोटबुक खोलें
इंस्टेंस बन जाने के बाद, JupyterLab खोलें को चुनें:
4. Vertex Pipelines का सेटअप
Vertex Pipelines का इस्तेमाल करने के लिए, हमें कुछ और लाइब्रेरी इंस्टॉल करनी होंगी:
- Kubeflow Pipelines: हम इस SDK टूल का इस्तेमाल करके अपनी पाइपलाइन बनाएंगे. Vertex Pipelines, Kubeflow Pipelines या TFX, दोनों की मदद से बनाई गई पाइपलाइन को चलाने की सुविधा देता है.
- Google Cloud Pipeline Components: इस लाइब्रेरी में पहले से बने कॉम्पोनेंट उपलब्ध होते हैं. इनकी मदद से, पाइपलाइन के चरणों से Vertex AI की सेवाओं के साथ आसानी से इंटरैक्ट किया जा सकता है.
पहला चरण: Python नोटबुक बनाना और लाइब्रेरी इंस्टॉल करना
सबसे पहले, अपने नोटबुक इंस्टेंस के लॉन्चर मेन्यू में जाकर, एक नोटबुक बनाएं. इस मेन्यू को ऐक्सेस करने के लिए, अपनी नोटबुक में सबसे ऊपर बाईं ओर मौजूद + आइकॉन पर क्लिक करें. इसके बाद, 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 Machine Learning के Dry beans dataset का इस्तेमाल करेंगे. यह डेटासेट, KOKLU, M. और OZKAN, I.A. ने तैयार किया है. (2020), "Multiclass Classification of Dry Beans Using Computer Vision and Machine Learning Techniques."In Computers and Electronics in Agriculture, 174, 105507. DOI.
हमारी पाइपलाइन का पहला चरण, Vertex AI में मैनेज किया गया डेटासेट बनाएगा. इसके लिए, BigQuery टेबल का इस्तेमाल किया जाएगा. इस टेबल में बीन्स के डेटा का वर्शन मौजूद है. डेटासेट को ट्रेनिंग जॉब के लिए इनपुट के तौर पर पास किया जाएगा. हमारे ट्रेनिंग कोड में, इस मैनेज किए गए डेटासेट को ऐक्सेस करने के लिए, एनवायरमेंट वैरिएबल का ऐक्सेस होगा.
हम कस्टम ट्रेनिंग जॉब को इस तरह सेट अप करेंगे:
- हमारे डेटा में बीन्स के टाइप को क्लासिफ़ाई करने के लिए, Scikit-learn
DecisionTreeClassifierमॉडल लिखो - ट्रेनिंग कोड को Docker कंटेनर में पैकेज करें और उसे Container Registry में पुश करें
इसके बाद, हम अपनी पाइपलाइन से सीधे तौर पर Vertex AI ट्रेनिंग जॉब शुरू कर पाएंगे. आइए, शुरू करें!
पहला चरण: Docker कंटेनर में ट्रेनिंग कोड तय करना
Notebooks इंस्टेंस में जाकर, लॉन्चर खोलें और टर्मिनल चुनें:
इसके बाद, कंटेनर में मौजूद कोड जोड़ने के लिए, यहां दी गई डायरेक्ट्री सेट अप करें:
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 के Container Registry सेक्शन पर जाएं. इससे आपको यह पुष्टि करने में मदद मिलेगी कि आपका कंटेनर वहां मौजूद है. यह कुछ-कुछ ऐसा दिखाई देगा:
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 में मैनेज किया गया डेटासेट बनाता है. अगर आपने अपनी कंसोल के Pipelines सेक्शन में मौजूद, इस डेटासेट लिंक पर क्लिक किया है:
आपको 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 पर अपनी पाइपलाइन चलाएं और एसडीके की मदद से पाइपलाइन रन शुरू करें
- कंसोल में, Vertex Pipelines का ग्राफ़ देखना और उसका विश्लेषण करना
- पहले से बनाए गए पाइपलाइन कॉम्पोनेंट का इस्तेमाल करके, अपनी पाइपलाइन में Vertex AI की सेवाएं जोड़ना
- बार-बार होने वाले पाइपलाइन जॉब शेड्यूल करना
Vertex के अलग-अलग हिस्सों के बारे में ज़्यादा जानने के लिए, दस्तावेज़ देखें.
9. साफ़-सफ़ाई सेवा
इसलिए, हमारा सुझाव है कि आप इस लैब में बनाए गए संसाधनों को मिटा दें, ताकि आपसे शुल्क न लिया जाए.
पहला चरण: Notebooks इंस्टेंस को रोकना या मिटाना
अगर आपको इस लैब में बनाई गई नोटबुक का इस्तेमाल जारी रखना है, तो हमारा सुझाव है कि इस्तेमाल न करने पर इसे बंद कर दें. Cloud Console में Notebooks के यूज़र इंटरफ़ेस (यूआई) में जाकर, नोटबुक चुनें. इसके बाद, बंद करें को चुनें. अगर आपको इंस्टेंस को पूरी तरह से मिटाना है, तो मिटाएं को चुनें:
दूसरा चरण: Cloud Storage बकेट मिटाना
स्टोरेज बकेट को मिटाने के लिए, Cloud Console में नेविगेशन मेन्यू का इस्तेमाल करके, स्टोरेज पर जाएं. इसके बाद, अपनी बकेट चुनें और मिटाएं पर क्लिक करें:
