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

1. खास जानकारी

इस लैब में, आपको Vertex ML Metadata की मदद से, अपनी Vertex Pipelines के मेटाडेटा का विश्लेषण करने का तरीका पता चलेगा.

आपको ये सब सीखने को मिलेगा

आपको, इनके बारे में जानकारी मिलेगी:

  • Kubeflow Pipelines SDK टूल की मदद से, एमएल पाइपलाइन बनाएं. यह सुविधा, Vertex AI में डेटासेट तैयार करने के साथ-साथ उस डेटासेट पर, पसंद के मुताबिक Scikit-learn मॉडल ट्रेन करती है और उसे डिप्लॉय करती है
  • आर्टफ़ैक्ट और मेटाडेटा जनरेट करने वाले कस्टम पाइपलाइन कॉम्पोनेंट लिखें
  • Vertex Pipelines की तुलना, Cloud Console और प्रोग्राम के हिसाब से, दोनों में की जा रही है
  • पाइपलाइन से बनाए गए आर्टफ़ैक्ट के लिए लीनेज का पता लगाएं
  • अपनी पाइपलाइन के चलाए जा रहे मेटाडेटा की क्वेरी करें

Google Cloud पर इस लैब को चलाने की कुल लागत करीब $2 है.

2. Vertex AI के बारे में जानकारी

यह लैब, Google Cloud पर उपलब्ध एआई (AI) प्रॉडक्ट के सबसे नए वर्शन का इस्तेमाल करती है. Vertex AI, Google Cloud के सभी मशीन लर्निंग प्लैटफ़ॉर्म को आसानी से डेवलप करने के लिए इंटिग्रेट करता है. पहले, AutoML और कस्टम मॉडल की मदद से ट्रेन किए गए मॉडल अलग-अलग सेवाओं से ऐक्सेस किए जा सकते थे. नई सेवा में, एक एपीआई से नए प्रॉडक्ट और इन दोनों का इस्तेमाल किया जा सकता है. आपके पास मौजूदा प्रोजेक्ट को Vertex AI पर माइग्रेट करने का विकल्प भी है.

मॉडल ट्रेनिंग और डिप्लॉयमेंट सेवाओं के अलावा, Vertex AI में कई MLOps प्रॉडक्ट भी शामिल हैं. जैसे, Vertex Pipelines, ML मेटाडेटा, मॉडल मॉनिटरिंग, Feature Store वगैरह. नीचे दिए गए डायग्राम में, Vertex AI के सभी प्रॉडक्ट ऑफ़र देखे जा सकते हैं.

Vertex प्रॉडक्ट की खास जानकारी

यह लैब Vertex Pipelines और Vertex ML Metadata पर फ़ोकस करता है.

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

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

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

tl;dr: पाइपलाइन की मदद से, मशीन लर्निंग वर्कफ़्लो को अपने-आप और फिर से बनाने में मदद मिलती है.

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

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

क्लाउड शेल शुरू करें

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

Cloud Shell को अनुमति दें

Cloud Shell चालू करें

Cloud Shell को चालू करने के लिए, Cloud Console में सबसे ऊपर दाईं ओर, नीचे दिए गए बटन पर क्लिक करें:

Cloud Shell चालू करें

अगर आपने Cloud Shell का इस्तेमाल पहले कभी नहीं किया है, तो आपको इसके बारे में जानकारी देने वाली एक इंटरमीडिएट स्क्रीन (पेज के फ़ोल्ड के नीचे) दिखेगी. अगर ऐसा है, तो जारी रखें पर क्लिक करें (यह आपको फिर कभी नहीं दिखेगा). एक बार इस्तेमाल होने वाली स्क्रीन कुछ इस तरह दिखती है:

Cloud Shell सेट अप करना

प्रावधान करने और Cloud Shell से कनेक्ट होने में कुछ ही समय लगेगा.

Cloud Shell शुरू करना

इस वर्चुअल मशीन में ऐसे सभी डेवलपमेंट टूल मौजूद हैं जिनकी आपको ज़रूरत है. यह पांच जीबी की स्थायी होम डायरेक्ट्री उपलब्ध कराता है और 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`

Cloud Shell में यह कमांड चलाएं, ताकि यह पुष्टि की जा सके कि gcloud के लिए कमांड को आपके प्रोजेक्ट के बारे में जानकारी है:

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//\'/}-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 पर क्लिक करें:

Vertex AI का मेन्यू

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

नई नोटबुक बनाएं

इसके बाद, बिना जीपीयू के TensorFlow Enterprise 2.3 (एलटीएस के साथ) इंस्टेंस टाइप चुनें:

TFE इंस्टेंस

डिफ़ॉल्ट विकल्पों का इस्तेमाल करें और फिर बनाएं पर क्लिक करें.

अपनी Notebook खोलें

इंस्टेंस बनाने के बाद, JupyterLab खोलें को चुनें:

Notebook खोलें

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 को चुनकर एक नोटबुक बनाएं:

Python3 नोटबुक बनाएं

इस लैब में इस्तेमाल की जाने वाली दोनों सेवाएं इंस्टॉल करने के लिए, पहले नोटबुक सेल में उपयोगकर्ता फ़्लैग सेट करें:

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 में एंडपॉइंट पर डिप्लॉय करें

इस पाइपलाइन में, हम KOKLU, M., और OZKAN, I.A. के यूसीआई मशीन लर्निंग ड्राई बीन डेटासेट का इस्तेमाल करेंगे. (2020), "कंप्यूटर विज़न ऐंड मशीन लर्निंग टेक्निक्स का इस्तेमाल करके ड्राई बीन का मल्टीक्लास क्लासिफ़िकेशन.":** कंप्यूटर ऐंड इलेक्ट्रॉनिक्स इन एग्रीकल्चर, 174, 105507. DOI.

यह एक टेबल वाला डेटासेट है. हमारी पाइपलाइन में, हम इस डेटासेट का इस्तेमाल स्किट-लर्न मॉडल को ट्रेनिंग देने, उसका आकलन करने, और उसे डिप्लॉय करने के लिए करेंगे. इस डेटासेट की मदद से, बीजों को उनकी विशेषताओं के आधार पर सात तरह की कैटगरी में बांटा जाता है. चलिए, कोडिंग शुरू करते हैं!

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 पैरामीटर ज़रूरी नहीं है. साथ ही, यह yml फ़ाइल के बारे में बताता है, ताकि कंपाइल किया गया कॉम्पोनेंट लिखा जा सके. सेल को चलाने के बाद, आपको अपने notebook के इंस्टेंस में वह फ़ाइल दिखेगी. अगर आपको यह कॉम्पोनेंट किसी के साथ शेयर करना है, तो उन्हें जनरेट की गई 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 से हमारे डेटा को Pandas DataFrame में डाउनलोड करने के लिए, BigQuery Python क्लाइंट लाइब्रेरी का इस्तेमाल करता है. इसके बाद, उस डेटा का एक आउटपुट आर्टफ़ैक्ट बनाता है, जो CSV फ़ाइल के तौर पर काम करता है. इसे हमारे अगले कॉम्पोनेंट में इनपुट के तौर पर पास किया जाएगा

स्किट-लर्निंग मॉडल को ट्रेनिंग देने के लिए एक कॉम्पोनेंट बनाएं

इस कॉम्पोनेंट में, हम पहले जनरेट की गई 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 कंसोल में हर पाइपलाइन देखने के लिए एक लिंक दिखेगा. अपनी पाइपलाइन के बारे में ज़्यादा जानकारी देखने के लिए वह लिंक खोलें:

पाइपलाइन चलाने का यूआरएल

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

sklearn पाइपलाइन पूरी हो गई है

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

6. पाइपलाइन आर्टफ़ैक्ट और वंशावली को समझना

पाइपलाइन ग्राफ़ में, आपको हर चरण के बाद छोटे बॉक्स दिखेंगे. वे आर्टफ़ैक्ट या पाइपलाइन चरण से जनरेट होने वाला आउटपुट होते हैं. आर्टफ़ैक्ट कई तरह के होते हैं. इस खास पाइपलाइन में, हमारे पास डेटासेट, मेट्रिक, मॉडल, और एंडपॉइंट आर्टफ़ैक्ट हैं. हर आर्टफ़ैक्ट के बारे में ज़्यादा जानकारी देखने के लिए, यूज़र इंटरफ़ेस (यूआई) पर सबसे ऊपर मौजूद, आर्टफ़ैक्ट बड़ा करें स्लाइडर पर क्लिक करें:

आर्टफ़ैक्ट को बड़ा करें

आर्टफ़ैक्ट पर क्लिक करने से, आपको उसके बारे में ज़्यादा जानकारी दिखेगी. इसमें, उसका यूआरआई भी शामिल है. उदाहरण के लिए, vertex_endpoint आर्टफ़ैक्ट पर क्लिक करने से आपको यूआरआई दिखेगा, जहां आपको Vertex AI कंसोल में डिप्लॉय किए गए उस एंडपॉइंट को देखने का विकल्प मिलेगा:

एंडपॉइंट आर्टफ़ैक्ट की जानकारी

Metrics आर्टफ़ैक्ट की मदद से, किसी खास पाइपलाइन चरण से जुड़ी कस्टम मेट्रिक पास की जा सकती हैं. हमने अपनी पाइपलाइन के sklearn_train कॉम्पोनेंट में, हमारे मॉडल के सटीक होने, फ़्रेमवर्क, और डेटासेट के साइज़ से जुड़ी मेट्रिक लॉग की हैं. यह जानकारी देखने के लिए मेट्रिक आर्टफ़ैक्ट पर क्लिक करें:

मॉडल मेट्रिक

हर एक आर्टफ़ैक्ट में Lineage है, जो उससे जुड़े दूसरे आर्टफ़ैक्ट के बारे में बताती है. अपनी पाइपलाइन के vertex_endpoint आर्टफ़ैक्ट पर फिर से क्लिक करें और फिर 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 प्रिंट करने पर, आपको कुछ ऐसा दिखेगा:

पाइपलाइन मेट्रिक का DataFrame

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

नए नोटबुक सेल में इन्हें चलाएं:

plt.plot(df["metric.dataset_size"], df["metric.accuracy"],label="Accuracy")
plt.title("Accuracy and dataset size")
plt.legend(loc=4)
plt.show()

आपको कुछ ऐसा दिखेगा:

Matplotlib मेटाडेटा ग्राफ़

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 मॉडल ट्रेन करती है और उसे डिप्लॉय करती है
  • आर्टफ़ैक्ट और मेटाडेटा जनरेट करने वाले कस्टम पाइपलाइन कॉम्पोनेंट लिखें
  • Vertex Pipelines की तुलना, Cloud Console और प्रोग्राम के हिसाब से, दोनों में की जा रही है
  • पाइपलाइन से बनाए गए आर्टफ़ैक्ट के लिए लीनेज का पता लगाएं
  • अपनी पाइपलाइन के चलाए जा रहे मेटाडेटा की क्वेरी करें

Vertex के अलग-अलग हिस्सों के बारे में ज़्यादा जानने के लिए, दस्तावेज़ देखें.

9. साफ़-सफ़ाई सेवा

आपसे शुल्क न लिया जाए, इसलिए हमारा सुझाव है कि आप इस लैब में बनाए गए संसाधनों को मिटा दें.

अपने Notebooks इंस्टेंस को रोकें या मिटाएं

यदि आप इस लैब में बनाए गए नोटबुक का उपयोग करना जारी रखना चाहते हैं, तो यह अनुशंसा की जाती है कि आप उपयोग में नहीं होने पर इसे बंद कर दें. अपने Cloud Console में Notebook के यूज़र इंटरफ़ेस (यूआई) से, नोटबुक चुनें और फिर बंद करें चुनें. अगर आपको इस इंस्टेंस को पूरी तरह से मिटाना है, तो मिटाएं चुनें:

इंस्टेंस रोकें

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

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

एंडपॉइंट को मिटाएं

Cloud Storage बकेट मिटाना

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

स्टोरेज मिटाएं