1. खास जानकारी
इस लैब में, आपको Vertex ML Metadata की मदद से, Vertex Pipelines की रन से मिले मेटाडेटा का विश्लेषण करने का तरीका बताया जाएगा.
आपको ये सब सीखने को मिलेगा
आपको, इनके बारे में जानकारी मिलेगी:
- Kubeflow Pipelines SDK का इस्तेमाल करके, एक एमएल पाइपलाइन बनाएं. यह पाइपलाइन, Vertex AI में एक डेटासेट बनाती है. साथ ही, उस डेटासेट पर Scikit-learn के कस्टम मॉडल को ट्रेन और डिप्लॉय करती है
- आर्टफ़ैक्ट और मेटाडेटा जनरेट करने वाले कस्टम पाइपलाइन कॉम्पोनेंट लिखना
- Cloud Console और प्रोग्राम के हिसाब से, Vertex Pipelines के रन की तुलना करना
- पाइपलाइन से जनरेट किए गए आर्टफ़ैक्ट के लिए लीनेज को ट्रेस करना
- अपनी पाइपलाइन के रन मेटाडेटा के बारे में क्वेरी करना
इस लैब को Google Cloud पर चलाने की कुल लागत करीब 2 डॉलर है.
2. Vertex AI के बारे में जानकारी
इस लैब में, Google Cloud पर उपलब्ध एआई प्रॉडक्ट की नई सुविधा का इस्तेमाल किया जाता है. Vertex AI, Google Cloud के सभी एमएल प्रॉडक्ट को एक साथ इंटिग्रेट करता है, ताकि डेवलपर को बेहतर अनुभव मिल सके. पहले, AutoML और कस्टम मॉडल से ट्रेन किए गए मॉडल को अलग-अलग सेवाओं के ज़रिए ऐक्सेस किया जा सकता था. नए ऑफ़र में, इन दोनों को एक ही एपीआई में शामिल किया गया है. साथ ही, इसमें अन्य नए प्रॉडक्ट भी शामिल हैं. मौजूदा प्रोजेक्ट को भी Vertex AI पर माइग्रेट किया जा सकता है.
मॉडल ट्रेनिंग और डिप्लॉयमेंट की सेवाओं के अलावा, Vertex AI में कई MLOps प्रॉडक्ट भी शामिल हैं. जैसे, Vertex Pipelines, एमएल मेटाडेटा, मॉडल मॉनिटरिंग, फ़ीचर स्टोर वगैरह. नीचे दिए गए डायग्राम में, Vertex AI के सभी प्रॉडक्ट ऑफ़रिंग देखी जा सकती हैं.
इस लैब में, Vertex Pipelines और Vertex ML Metadata पर फ़ोकस किया गया है.
अगर आपको 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
कमांड आउटपुट
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
यह पुष्टि करने के लिए कि 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, दोनों की मदद से बनाई गई पाइपलाइन को चलाने की सुविधा देता है.
- Vertex AI SDK: यह SDK, Vertex AI API को कॉल करने के अनुभव को बेहतर बनाता है. हम इसका इस्तेमाल, Vertex AI पर अपनी पाइपलाइन चलाने के लिए करेंगे.
Python नोटबुक बनाना और लाइब्रेरी इंस्टॉल करना
सबसे पहले, अपने Notebook इंस्टेंस में लॉन्चर मेन्यू से, Python 3 को चुनकर एक नोटबुक बनाएं:
इस लैब में इस्तेमाल की जाने वाली दोनों सेवाओं को इंस्टॉल करने के लिए, पहले नोटबुक सेल में उपयोगकर्ता फ़्लैग सेट करें:
USER_FLAG = "--user"
इसके बाद, अपनी नोटबुक से यह कोड चलाएं:
!pip3 install {USER_FLAG} google-cloud-aiplatform==1.7.0
!pip3 install {USER_FLAG} kfp==1.8.9
इन पैकेज को इंस्टॉल करने के बाद, आपको कर्नल को रीस्टार्ट करना होगा:
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__))"
इसके बाद, पुष्टि करें कि आपके Vertex AI SDK टूल का वर्शन >= 1.6.2 है:
!pip list | grep aiplatform
अपना प्रोजेक्ट आईडी और बकेट सेट करना
इस लैब में, आपको अपने 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"
लाइब्रेरी इंपोर्ट करना
इस कोडलैब में इस्तेमाल की जाने वाली लाइब्रेरी इंपोर्ट करने के लिए, यह कोड जोड़ें:
import matplotlib.pyplot as plt
import pandas as pd
from kfp.v2 import compiler, dsl
from kfp.v2.dsl import pipeline, component, Artifact, Dataset, Input, Metrics, Model, Output, InputPath, OutputPath
from google.cloud import aiplatform
# We'll use this namespace for metadata querying
from google.cloud import aiplatform_v1
कॉन्सटेंट तय करना
पाइपलाइन बनाने से पहले, हमें कुछ कॉन्स्टेंट वैरिएबल तय करने होंगे. 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. कस्टम कॉम्पोनेंट की मदद से, तीन चरणों वाली पाइपलाइन बनाना
इस लैब का मकसद, पाइपलाइन रन से मेटाडेटा को समझना है. इसके लिए, हमें Vertex Pipelines पर चलने वाली पाइपलाइन की ज़रूरत होगी. हम यहीं से शुरुआत करेंगे. यहां हम तीन चरणों वाली पाइपलाइन तय करेंगे. इसमें ये कस्टम कॉम्पोनेंट शामिल होंगे:
get_dataframe: BigQuery टेबल से डेटा वापस पाना और उसे Pandas DataFrame में बदलनाtrain_sklearn_model: Pandas DataFrame का इस्तेमाल करके, Scikit Learn मॉडल को ट्रेन करें और उसे कुछ मेट्रिक के साथ एक्सपोर्ट करेंdeploy_model: एक्सपोर्ट किए गए Scikit Learn मॉडल को Vertex AI में किसी एंडपॉइंट पर डिप्लॉय करना
इस पाइपलाइन में, हम 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.
यह एक टेबल वाला डेटासेट है. हमारी पाइपलाइन में, हम इस डेटासेट का इस्तेमाल Scikit-learn मॉडल को ट्रेन करने, उसका आकलन करने, और उसे डिप्लॉय करने के लिए करेंगे. यह मॉडल, बीन्स की विशेषताओं के आधार पर उन्हें सात में से किसी एक टाइप में क्लासिफ़ाई करता है. चलिए, कोडिंग शुरू करते हैं!
Python फ़ंक्शन पर आधारित कॉम्पोनेंट बनाना
KFP SDK का इस्तेमाल करके, Python फ़ंक्शन के आधार पर कॉम्पोनेंट बनाए जा सकते हैं. हम इसका इस्तेमाल इस पाइपलाइन के तीन कॉम्पोनेंट के लिए करेंगे.
BigQuery का डेटा डाउनलोड करना और उसे CSV फ़ाइल में बदलना
सबसे पहले, हम get_dataframe कॉम्पोनेंट बनाएंगे:
@component(
packages_to_install=["google-cloud-bigquery", "pandas", "pyarrow", "db-dtypes"],
base_image="python:3.9",
output_component_file="create_dataset.yaml"
)
def get_dataframe(
bq_table: str,
output_data_path: OutputPath("Dataset")
):
from google.cloud import bigquery
import pandas as pd
import os
project_number = os.environ["CLOUD_ML_PROJECT_ID"]
bqclient = bigquery.Client(project=project_number)
table = bigquery.TableReference.from_string(
bq_table
)
rows = bqclient.list_rows(
table
)
dataframe = rows.to_dataframe(
create_bqstorage_client=True,
)
dataframe = dataframe.sample(frac=1, random_state=2)
dataframe.to_csv(output_data_path)
आइए, इस कॉम्पोनेंट में होने वाली गतिविधियों के बारे में ज़्यादा जानें:
- पाइपलाइन चलाने पर,
@componentडेकोरेटर इस फ़ंक्शन को कॉम्पोनेंट में कंपाइल करता है. कस्टम कॉम्पोनेंट लिखते समय, आपको इसका इस्तेमाल करना होगा. base_imageपैरामीटर, उस कंटेनर इमेज के बारे में बताता है जिसका इस्तेमाल यह कॉम्पोनेंट करेगा.- यह कॉम्पोनेंट कुछ Python लाइब्रेरी का इस्तेमाल करेगा. इन्हें हम
packages_to_installपैरामीटर के ज़रिए तय करते हैं. output_component_fileपैरामीटर का इस्तेमाल करना ज़रूरी नहीं है. यह उस YAML फ़ाइल के बारे में बताता है जिसमें कंपाइल किए गए कॉम्पोनेंट को लिखना है. सेल चलाने के बाद, आपको दिखेगा कि फ़ाइल को आपके नोटबुक इंस्टेंस में लिखा गया है. अगर आपको इस कॉम्पोनेंट को किसी के साथ शेयर करना है, तो उसे जनरेट की गई YAML फ़ाइल भेजी जा सकती है. इसके बाद, वह व्यक्ति इस फ़ाइल को यहां दिए गए तरीके से लोड कर सकता है:
# This is optional, it shows how to load a component from a yaml file
# dataset_component = kfp.components.load_component_from_file('./create_dataset.yaml')
- इसके बाद, यह कॉम्पोनेंट BigQuery Python क्लाइंट लाइब्रेरी का इस्तेमाल करके, BigQuery से हमारे डेटा को Pandas DataFrame में डाउनलोड करता है. इसके बाद, उस डेटा का आउटपुट आर्टफ़ैक्ट, CSV फ़ाइल के तौर पर बनाता है. इसे हमारे अगले कॉम्पोनेंट में इनपुट के तौर पर पास किया जाएगा
Scikit-learn मॉडल को ट्रेन करने के लिए कॉम्पोनेंट बनाना
इस कॉम्पोनेंट में, हम पहले जनरेट की गई CSV फ़ाइल का इस्तेमाल करेंगे. साथ ही, इसका इस्तेमाल Scikit-learn डिसिज़न ट्री मॉडल को ट्रेन करने के लिए करेंगे. यह कॉम्पोनेंट, नतीजे के तौर पर मिले Scikit मॉडल को एक्सपोर्ट करता है. साथ ही, Metrics आर्टफ़ैक्ट को भी एक्सपोर्ट करता है. इस आर्टफ़ैक्ट में, मॉडल की सटीकता, फ़्रेमवर्क, और मॉडल को ट्रेन करने के लिए इस्तेमाल किए गए डेटासेट का साइज़ शामिल होता है:
@component(
packages_to_install=["sklearn", "pandas", "joblib", "db-dtypes"],
base_image="python:3.9",
output_component_file="beans_model_component.yaml",
)
def sklearn_train(
dataset: Input[Dataset],
metrics: Output[Metrics],
model: Output[Model]
):
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import roc_curve
from sklearn.model_selection import train_test_split
from joblib import dump
import pandas as pd
df = pd.read_csv(dataset.path)
labels = df.pop("Class").tolist()
data = df.values.tolist()
x_train, x_test, y_train, y_test = train_test_split(data, labels)
skmodel = DecisionTreeClassifier()
skmodel.fit(x_train,y_train)
score = skmodel.score(x_test,y_test)
print('accuracy is:',score)
metrics.log_metric("accuracy",(score * 100.0))
metrics.log_metric("framework", "Scikit Learn")
metrics.log_metric("dataset_size", len(df))
dump(skmodel, model.path + ".joblib")
मॉडल को Vertex AI पर अपलोड और डिप्लॉय करने के लिए, कॉम्पोनेंट तय करना
आखिर में, हमारा आखिरी कॉम्पोनेंट पिछले चरण से ट्रेन किए गए मॉडल को लेगा, उसे Vertex AI पर अपलोड करेगा, और उसे किसी एंडपॉइंट पर डिप्लॉय करेगा:
@component(
packages_to_install=["google-cloud-aiplatform"],
base_image="python:3.9",
output_component_file="beans_deploy_component.yaml",
)
def deploy_model(
model: Input[Model],
project: str,
region: str,
vertex_endpoint: Output[Artifact],
vertex_model: Output[Model]
):
from google.cloud import aiplatform
aiplatform.init(project=project, location=region)
deployed_model = aiplatform.Model.upload(
display_name="beans-model-pipeline",
artifact_uri = model.uri.replace("model", ""),
serving_container_image_uri="us-docker.pkg.dev/vertex-ai/prediction/sklearn-cpu.0-24:latest"
)
endpoint = deployed_model.deploy(machine_type="n1-standard-4")
# Save data to the output params
vertex_endpoint.uri = endpoint.resource_name
vertex_model.uri = deployed_model.resource_name
यहां हम Vertex AI SDK का इस्तेमाल करके, मॉडल को अपलोड कर रहे हैं. इसके लिए, अनुमान लगाने के लिए पहले से बनाए गए कंटेनर का इस्तेमाल किया जा रहा है. इसके बाद, यह मॉडल को किसी एंडपॉइंट पर डिप्लॉय करता है. साथ ही, मॉडल और एंडपॉइंट, दोनों संसाधनों के यूआरआई दिखाता है. इस कोडलैब में आगे, आपको इस डेटा को आर्टफ़ैक्ट के तौर पर वापस लाने का मतलब बताया जाएगा.
पाइपलाइन को तय करना और कंपाइल करना
हमने अपने तीन कॉम्पोनेंट तय कर लिए हैं. अब हम पाइपलाइन की परिभाषा बनाएंगे. इसमें बताया गया है कि इनपुट और आउटपुट आर्टफ़ैक्ट, चरणों के बीच कैसे फ़्लो करते हैं:
@pipeline(
# Default pipeline root. You can override it when submitting the pipeline.
pipeline_root=PIPELINE_ROOT,
# A name for the pipeline.
name="mlmd-pipeline",
)
def pipeline(
bq_table: str = "",
output_data_path: str = "data.csv",
project: str = PROJECT_ID,
region: str = REGION
):
dataset_task = get_dataframe(bq_table)
model_task = sklearn_train(
dataset_task.output
)
deploy_task = deploy_model(
model=model_task.outputs["model"],
project=project,
region=region
)
इससे एक JSON फ़ाइल जनरेट होगी. इसका इस्तेमाल पाइपलाइन चलाने के लिए किया जाएगा:
compiler.Compiler().compile(
pipeline_func=pipeline, package_path="mlmd_pipeline.json"
)
दो पाइपलाइन रन शुरू करना
इसके बाद, हम अपनी पाइपलाइन को दो बार चलाएंगे. सबसे पहले, हम पाइपलाइन के जॉब आईडी के लिए टाइमस्टैंप तय करते हैं:
from datetime import datetime
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
ध्यान रखें कि पाइपलाइन को चलाने के लिए, हम एक पैरामीटर का इस्तेमाल करते हैं: वह bq_table जिसका इस्तेमाल हमें ट्रेनिंग डेटा के लिए करना है. इस पाइपलाइन रन में, बीन्स डेटासेट के छोटे वर्शन का इस्तेमाल किया जाएगा:
run1 = aiplatform.PipelineJob(
display_name="mlmd-pipeline",
template_path="mlmd_pipeline.json",
job_id="mlmd-pipeline-small-{0}".format(TIMESTAMP),
parameter_values={"bq_table": "sara-vertex-demos.beans_demo.small_dataset"},
enable_caching=True,
)
इसके बाद, उसी डेटासेट के बड़े वर्शन का इस्तेमाल करके, पाइपलाइन का दूसरा रन बनाएं.
run2 = aiplatform.PipelineJob(
display_name="mlmd-pipeline",
template_path="mlmd_pipeline.json",
job_id="mlmd-pipeline-large-{0}".format(TIMESTAMP),
parameter_values={"bq_table": "sara-vertex-demos.beans_demo.large_dataset"},
enable_caching=True,
)
आखिर में, दोनों रन के लिए पाइपलाइन एक्ज़ीक्यूशन शुरू करें. इसे दो अलग-अलग नोटबुक सेल में करना सबसे सही तरीका है, ताकि आपको हर रन का आउटपुट दिख सके.
run1.submit()
इसके बाद, दूसरा रन शुरू करें:
run2.submit()
इस सेल को चलाने के बाद, आपको Vertex AI कंसोल में हर पाइपलाइन को देखने का लिंक दिखेगा. अपनी पाइपलाइन के बारे में ज़्यादा जानकारी देखने के लिए, यह लिंक खोलें:
यह प्रोसेस पूरी होने में, हर बार करीब 10 से 15 मिनट लगते हैं. इसके पूरा होने पर, आपको कुछ ऐसा दिखेगा:
अब आपके पास दो पाइपलाइन रन पूरे हो चुके हैं. इसलिए, अब पाइपलाइन आर्टफ़ैक्ट, मेट्रिक, और लीनेज को ज़्यादा बारीकी से देखा जा सकता है.
6. पाइपलाइन आर्टफ़ैक्ट और लीनेज को समझना
अपने पाइपलाइन ग्राफ़ में, आपको हर चरण के बाद छोटे बॉक्स दिखेंगे. इन्हें आर्टफ़ैक्ट कहा जाता है. ये पाइपलाइन के किसी चरण से जनरेट होने वाला आउटपुट होता है. आर्टफ़ैक्ट कई तरह के होते हैं. इस पाइपलाइन में, हमारे पास डेटासेट, मेट्रिक, मॉडल, और एंडपॉइंट आर्टफ़ैक्ट हैं. हर एक के बारे में ज़्यादा जानकारी देखने के लिए, यूज़र इंटरफ़ेस (यूआई) में सबसे ऊपर मौजूद आर्टफ़ैक्ट बड़ा करें स्लाइडर पर क्लिक करें:
किसी आर्टफ़ैक्ट पर क्लिक करने से, आपको उसके बारे में ज़्यादा जानकारी दिखेगी. इसमें उसका यूआरआई भी शामिल है. उदाहरण के लिए, vertex_endpoint आर्टफ़ैक्ट पर क्लिक करने से, आपको वह यूआरआई दिखेगा जहां आपको Vertex AI कंसोल में डिप्लॉय किया गया एंडपॉइंट मिलेगा:
Metrics आर्टफ़ैक्ट की मदद से, किसी पाइपलाइन के चरण से जुड़ी कस्टम मेट्रिक पास की जा सकती हैं. हमने अपनी पाइपलाइन के sklearn_train कॉम्पोनेंट में, अपने मॉडल की सटीकता, फ़्रेमवर्क, और डेटासेट के साइज़ के बारे में मेट्रिक लॉग की हैं. यह जानकारी देखने के लिए, मेट्रिक आर्टफ़ैक्ट पर क्लिक करें:
हर आर्टफ़ैक्ट का वंशानुक्रम होता है. इससे पता चलता है कि वह किन अन्य आर्टफ़ैक्ट से जुड़ा है. अपनी पाइपलाइन के vertex_endpoint आर्टफ़ैक्ट पर फिर से क्लिक करें. इसके बाद, वंशावली देखें बटन पर क्लिक करें:
इससे एक नया टैब खुलेगा. इसमें आपको चुने गए आर्टफ़ैक्ट से जुड़े सभी आर्टफ़ैक्ट दिखेंगे. आपका लीनेज ग्राफ़ कुछ ऐसा दिखेगा:
इससे हमें इस एंडपॉइंट से जुड़े मॉडल, मेट्रिक, और डेटासेट के बारे में पता चलता है. यह जानकारी आपके काम की क्यों है? ऐसा हो सकता है कि आपने किसी मॉडल को कई एंडपॉइंट पर डिप्लॉय किया हो. इसके अलावा, आपको उस एंडपॉइंट पर डिप्लॉय किए गए मॉडल को ट्रेन करने के लिए इस्तेमाल किए गए डेटासेट के बारे में जानना हो. वंशावली ग्राफ़ की मदद से, अपने एमएल सिस्टम के बाकी हिस्सों के संदर्भ में हर आर्टफ़ैक्ट को समझा जा सकता है. हम इस कोडलैब में बाद में देखेंगे कि प्रोग्राम के हिसाब से भी लीनेज को ऐक्सेस किया जा सकता है.
7. पाइपलाइन रन की तुलना करना
ऐसा हो सकता है कि एक पाइपलाइन को कई बार चलाया जाए. ऐसा अलग-अलग इनपुट पैरामीटर, नए डेटा या आपकी टीम के अलग-अलग लोगों की वजह से हो सकता है. पाइपलाइन रन को ट्रैक करने के लिए, अलग-अलग मेट्रिक के हिसाब से उनकी तुलना करने का तरीका होना चाहिए. इस सेक्शन में, हम रन की तुलना करने के दो तरीकों के बारे में जानेंगे.
Pipelines यूज़र इंटरफ़ेस (यूआई) में रन की तुलना करना
Cloud Console में, अपने पाइपलाइन डैशबोर्ड पर जाएं. इससे आपको हर उस पाइपलाइन रन की खास जानकारी मिलती है जिसे आपने लागू किया है. पिछले दो रन की जांच करें. इसके बाद, सबसे ऊपर मौजूद तुलना करें बटन पर क्लिक करें:
इससे हम उस पेज पर पहुंच जाते हैं जहां हमने चुने गए हर रन के लिए, इनपुट पैरामीटर और मेट्रिक की तुलना की जा सकती है. इन दोनों रन के लिए, BigQuery की अलग-अलग टेबल, डेटासेट के साइज़, और सटीक अनुमान की वैल्यू देखें:
इस यूज़र इंटरफ़ेस (यूआई) की मदद से, दो से ज़्यादा रन की तुलना की जा सकती है. साथ ही, अलग-अलग पाइपलाइन के रन की तुलना भी की जा सकती है.
Vertex AI SDK की मदद से रन की तुलना करना
कई पाइपलाइन एक्ज़ीक्यूशन के साथ, आपको इन तुलना मेट्रिक को प्रोग्राम के हिसाब से पाने का तरीका चाहिए. इससे मेट्रिक की ज़्यादा जानकारी मिल सकती है और विज़ुअलाइज़ेशन बनाए जा सकते हैं.
रन मेटाडेटा को ऐक्सेस करने के लिए, aiplatform.get_pipeline_df() तरीके का इस्तेमाल किया जा सकता है. यहां हमें एक ही पाइपलाइन के पिछले दो रन का मेटाडेटा मिलेगा. साथ ही, इसे Pandas DataFrame में लोड किया जाएगा. यहां pipeline पैरामीटर, पाइपलाइन की परिभाषा में पाइपलाइन को दिए गए नाम को दिखाता है:
df = aiplatform.get_pipeline_df(pipeline="mlmd-pipeline")
df
DataFrame को प्रिंट करने पर, आपको कुछ ऐसा दिखेगा:
हमने यहां सिर्फ़ दो बार पाइपलाइन को लागू किया है. हालांकि, ज़्यादा बार लागू करने पर आपको कई मेट्रिक मिल सकती हैं. इसके बाद, हम matplotlib की मदद से कस्टम विज़ुअलाइज़ेशन बनाएंगे. इससे हमें अपने मॉडल की सटीकता और ट्रेनिंग के लिए इस्तेमाल किए गए डेटा की मात्रा के बीच संबंध देखने में मदद मिलेगी.
नई नोटबुक सेल में यह कोड चलाएं:
plt.plot(df["metric.dataset_size"], df["metric.accuracy"],label="Accuracy")
plt.title("Accuracy and dataset size")
plt.legend(loc=4)
plt.show()
आपको कुछ ऐसा दिखेगा:
8. पाइपलाइन की मेट्रिक के लिए क्वेरी करना
पाइपलाइन की सभी मेट्रिक का DataFrame पाने के अलावा, आपको अपने एमएल सिस्टम में बनाए गए आर्टफ़ैक्ट के बारे में प्रोग्राम के हिसाब से क्वेरी करनी पड़ सकती है. इसके बाद, आपके पास कस्टम डैशबोर्ड बनाने का विकल्प होता है. इसके अलावा, अपनी कंपनी के अन्य लोगों को खास आर्टफ़ैक्ट के बारे में जानकारी दी जा सकती है.
सभी मॉडल आर्टफ़ैक्ट पाना
इस तरह से आर्टफ़ैक्ट के बारे में क्वेरी करने के लिए, हम MetadataServiceClient बनाएंगे:
API_ENDPOINT = "{}-aiplatform.googleapis.com".format(REGION)
metadata_client = aiplatform_v1.MetadataServiceClient(
client_options={
"api_endpoint": API_ENDPOINT
}
)
इसके बाद, हम उस एंडपॉइंट को list_artifacts अनुरोध भेजेंगे. साथ ही, एक फ़िल्टर पास करेंगे, जिससे यह पता चलेगा कि हमें जवाब में कौनसे आर्टफ़ैक्ट चाहिए. सबसे पहले, अपने प्रोजेक्ट में मौजूद उन सभी आर्टफ़ैक्ट को इकट्ठा करते हैं जो मॉडल हैं. इसके लिए, अपनी नोटबुक में यह कोड चलाएं:
MODEL_FILTER="schema_title = \"system.Model\""
artifact_request = aiplatform_v1.ListArtifactsRequest(
parent="projects/{0}/locations/{1}/metadataStores/default".format(PROJECT_ID, REGION),
filter=MODEL_FILTER
)
model_artifacts = metadata_client.list_artifacts(artifact_request)
model_artifacts रिस्पॉन्स में, आपके प्रोजेक्ट में मौजूद हर मॉडल आर्टफ़ैक्ट के लिए एक इटरेबल ऑब्जेक्ट होता है. साथ ही, हर मॉडल के लिए उससे जुड़ा मेटाडेटा भी होता है.
ऑब्जेक्ट को फ़िल्टर करना और उन्हें DataFrame में दिखाना
अगर हम क्वेरी के नतीजे को आसानी से देख पाएं, तो यह हमारे लिए मददगार होगा. इसके बाद, 10 अगस्त, 2021 के बाद बनाए गए उन सभी आर्टफ़ैक्ट को पाएं जिनकी स्थिति LIVE है. इस अनुरोध को पूरा करने के बाद, हम नतीजों को Pandas DataFrame में दिखाएंगे. सबसे पहले, अनुरोध पूरा करें:
LIVE_FILTER = "create_time > \"2021-08-10T00:00:00-00:00\" AND state = LIVE"
artifact_req = {
"parent": "projects/{0}/locations/{1}/metadataStores/default".format(PROJECT_ID, REGION),
"filter": LIVE_FILTER
}
live_artifacts = metadata_client.list_artifacts(artifact_req)
इसके बाद, नतीजों को DataFrame में दिखाएं:
data = {'uri': [], 'createTime': [], 'type': []}
for i in live_artifacts:
data['uri'].append(i.uri)
data['createTime'].append(i.create_time)
data['type'].append(i.schema_title)
df = pd.DataFrame.from_dict(data)
df
आपको कुछ ऐसा दिखेगा:
यहां बताए गए तरीके के अलावा, अन्य तरीकों से भी आर्टफ़ैक्ट फ़िल्टर किए जा सकते हैं.
अब आपने यह लैब पूरी कर ली है!
🎉 बधाई हो! 🎉
आपने Vertex AI का इस्तेमाल करके ये काम करने का तरीका सीखा है:
- Kubeflow Pipelines SDK का इस्तेमाल करके, एक एमएल पाइपलाइन बनाएं. यह पाइपलाइन, Vertex AI में एक डेटासेट बनाती है. साथ ही, उस डेटासेट पर Scikit-learn के कस्टम मॉडल को ट्रेन और डिप्लॉय करती है
- आर्टफ़ैक्ट और मेटाडेटा जनरेट करने वाले कस्टम पाइपलाइन कॉम्पोनेंट लिखना
- Cloud Console और प्रोग्राम के हिसाब से, Vertex Pipelines के रन की तुलना करना
- पाइपलाइन से जनरेट किए गए आर्टफ़ैक्ट के लिए लीनेज को ट्रेस करना
- अपनी पाइपलाइन के रन मेटाडेटा के बारे में क्वेरी करना
Vertex के अलग-अलग हिस्सों के बारे में ज़्यादा जानने के लिए, दस्तावेज़ देखें.
9. साफ़-सफ़ाई सेवा
इसलिए, हमारा सुझाव है कि आप इस लैब में बनाए गए संसाधनों को मिटा दें, ताकि आपसे शुल्क न लिया जाए.
Notebooks इंस्टेंस को रोकना या मिटाना
अगर आपको इस लैब में बनाई गई नोटबुक का इस्तेमाल जारी रखना है, तो हमारा सुझाव है कि इस्तेमाल न करने पर इसे बंद कर दें. Cloud Console में Notebooks के यूज़र इंटरफ़ेस (यूआई) में जाकर, नोटबुक चुनें. इसके बाद, बंद करें को चुनें. अगर आपको इंस्टेंस को पूरी तरह से मिटाना है, तो मिटाएं को चुनें:
Vertex AI के एंडपॉइंट मिटाना
डिप्लॉय किए गए एंडपॉइंट को मिटाने के लिए, Vertex AI कंसोल के एंडपॉइंट सेक्शन पर जाएं और मिटाएं आइकॉन पर क्लिक करें:
Cloud Storage बकेट मिटाना
स्टोरेज बकेट को मिटाने के लिए, Cloud Console में नेविगेशन मेन्यू का इस्तेमाल करके, स्टोरेज पर जाएं. इसके बाद, अपनी बकेट चुनें और मिटाएं पर क्लिक करें:
