पाइपलाइन के साथ Vertex ML मेटाडेटा का इस्तेमाल करना

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, ML मेटाडेटा, मॉडल मॉनिटरिंग, Feature Store वगैरह. नीचे दिए गए डायग्राम में, Vertex AI के सभी प्रॉडक्ट ऑफ़र देखे जा सकते हैं.

इस लैब में, Vertex Pipelines और Vertex ML मेटाडेटा पर फ़ोकस किया गया है.

अगर आपको Vertex AI के बारे में कोई सुझाव देना है, तो कृपया सहायता पेज देखें.

एमएल पाइपलाइन आपके लिए मददगार क्यों हैं?

आगे बढ़ने से पहले, आइए यह जानें कि आपको पाइपलाइन का इस्तेमाल क्यों करना चाहिए. मान लें कि आपने एक ऐसा एमएल वर्कफ़्लो बनाया है जिसमें डेटा प्रोसेस करना, मॉडल को ट्रेनिंग देना, हाइपरपैरामीटर ट्यून करना, आकलन करना, और मॉडल को डिप्लॉय करना शामिल है. इनमें से हर चरण में अलग-अलग डिपेंडेंसी हो सकती हैं. अगर पूरे वर्कफ़्लो को एक ही तरह से मैनेज किया जाता है, तो यह मुश्किल हो सकता है. एमएल प्रोसेस का दायरा बढ़ाने के बाद, आपको अपनी टीम के अन्य लोगों के साथ एमएल वर्कफ़्लो शेयर करने की ज़रूरत पड़ सकती है. इससे वे इसे चला सकेंगे और कोड में योगदान दे सकेंगे. भरोसेमंद और दोबारा बनाई जाने वाली प्रोसेस के बिना, काम करना मुश्किल हो सकता है. पाइपलाइन के साथ, आपकी एमएल प्रोसेस का हर चरण उसका अपना कंटेनर होता है. इसकी मदद से, अलग-अलग चरण बनाए जा सकते हैं. साथ ही, हर चरण के इनपुट और आउटपुट को दोबारा इस्तेमाल किए जा सकने वाले तरीके से ट्रैक किया जा सकता है. आपके पास अपने क्लाउड एनवायरमेंट में अन्य इवेंट के आधार पर, पाइपलाइन चलाने को शेड्यूल या ट्रिगर करने का विकल्प भी होता है. जैसे, नया ट्रेनिंग डेटा उपलब्ध होने पर, पाइपलाइन चलाना शुरू करना.

खास जानकारी: पाइपलाइन की मदद से, अपने एमएल वर्कफ़्लो को ऑटोमेट और फिर से चलाया जा सकता है.

3. क्लाउड एनवायरमेंट सेटअप करना

इस कोडलैब को चलाने के लिए, आपके पास Google Cloud Platform का ऐसा प्रोजेक्ट होना चाहिए जिसमें बिलिंग की सुविधा चालू हो. प्रोजेक्ट बनाने के लिए, यहां दिए गए निर्देशों का पालन करें.

Cloud Shell शुरू करना

इस लैब में, आपको Cloud Shell सेशन में काम करना है. यह एक कमांड इंटरप्रिटर है, जिसे Google के क्लाउड में चल रही वर्चुअल मशीन होस्ट करती है. इस सेक्शन को अपने कंप्यूटर पर भी आसानी से चलाया जा सकता है. हालांकि, Cloud Shell का इस्तेमाल करने पर, सभी को एक ही तरह के एनवायरमेंट में, दोहराए जा सकने वाले अनुभव का ऐक्सेस मिलता है. लैब के बाद, अपने कंप्यूटर पर इस सेक्शन को फिर से आज़माएं.

पहली बार Cloud Shell में कोई ऐसा अनुरोध करने पर जिसके लिए अनुमति की ज़रूरत होती है, आपको नीचे दिखाए गए "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

कमांड आउटपुट

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

ध्यान दें: gcloud कमांड-लाइन टूल, Google Cloud का बेहतरीन और यूनिफ़ाइड कमांड-लाइन टूल है. यह Cloud Shell में पहले से इंस्टॉल होती है. आपको टैब की मदद से शब्द पूरा करने की सुविधा दिखेगी. ज़्यादा जानकारी के लिए, gcloud कमांड-लाइन टूल की खास जानकारी देखें.

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 भी शामिल है, जिसमें हमारे मौजूदा क्लाउड प्रोजेक्ट का नाम होता है. हम इस लैब में अलग-अलग जगहों पर इसका इस्तेमाल करेंगे. इसे देखने के लिए, यह तरीका अपनाएं:

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//\'/}[e-mail]"
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 (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: Scikit Learn मॉडल को ट्रेनिंग देने और एक्सपोर्ट करने के लिए, Pandas DataFrame का इस्तेमाल करें. साथ ही, कुछ मेट्रिक का इस्तेमाल करें
• deploy_model: एक्सपोर्ट किए गए Scikit Learn मॉडल को Vertex AI के एंडपॉइंट पर डिप्लॉय करना

इस पाइपलाइन में, हम UCI मशीन लर्निंग ड्राई बीन्स डेटासेट का इस्तेमाल करेंगे. यह डेटासेट, KOKLU, M. और OZKAN, I.A. से लिया गया है. (2020), "कंप्यूटर विज़न ऐंड मशीन लर्निंग टेक्नोलॉजी का इस्तेमाल करके मल्टीक्लास क्लासिफ़िकेशन ऑफ़ ड्राई बीन ऐंड मशीन लर्निंग टेक्निक्स.":**इन कंप्यूटर ऐंड इलेक्ट्रॉनिक्स इन एग्रीकल्चर, 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 कंसोल में हर पाइपलाइन देखने के लिए एक लिंक दिखेगा. अपनी पाइपलाइन के बारे में ज़्यादा जानकारी देखने के लिए, वह लिंक खोलें:

यह प्रोसेस पूरी होने के बाद, आपको कुछ ऐसा दिखेगा:

अब आपके पास दो पाइपलाइन रन हो चुके हैं. इसलिए, अब पाइपलाइन आर्टफ़ैक्ट, मेट्रिक, और लीनेज की बारीकी से जांच की जा सकती है.

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. पाइपलाइन मेट्रिक पर क्वेरी की जा रही है

सभी पाइपलाइन मेट्रिक का डेटाफ़्रेम पाने के अलावा, हो सकता है कि आप अपने एमएल सिस्टम में बनाए गए आर्टफ़ैक्ट के लिए प्रोग्राम के हिसाब से क्वेरी करना चाहें. वहां से, कस्टम डैशबोर्ड बनाया जा सकता है या अपने संगठन के अन्य लोगों को खास आर्टफ़ैक्ट की जानकारी दी जा सकती है.

मॉडल के सभी आर्टफ़ैक्ट पाना

इस तरह से आर्टफ़ैक्ट के बारे में क्वेरी करने के लिए, हम एक 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 में नोटबुक यूज़र इंटरफ़ेस (यूआई) से, नोटबुक चुनें. इसके बाद, बंद करें को चुनें. अगर आपको इस इंस्टेंस को पूरी तरह से मिटाना है, तो मिटाएं चुनें:

Vertex AI के एंडपॉइंट मिटाना

डिप्लॉय किए गए एंडपॉइंट को मिटाने के लिए, Vertex AI कंसोल के एंडपॉइंट सेक्शन पर जाएं और मिटाएं आइकॉन पर क्लिक करें:

अपनी Cloud Storage बकेट मिटाना

स्टोरेज बकेट मिटाने के लिए, अपने Cloud Console में नेविगेशन मेन्यू का इस्तेमाल करके, स्टोरेज पर जाएं. इसके बाद, अपनी बकेट चुनें और 'मिटाएं' पर क्लिक करें: