इस पेज का अनुवाद Cloud Translation API से किया गया है.

Vertex Pipelines के बारे में जानकारी

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

इस लैब में, आपको Vertex Pipelines की मदद से एमएल पाइपलाइन बनाने और उन्हें चलाने का तरीका पता चलेगा.

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

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

बढ़ाने लायक एमएल पाइपलाइन बनाने के लिए, Kubeflow Pipelines SDK टूल का इस्तेमाल करें
टेक्स्ट इनपुट लेने वाली, तीन चरणों वाली इंट्रो पाइपलाइन बनाना और चलाना
ऐसी पाइपलाइन बनाएं और चलाएं जो ऑटोमेटेड मशीन लर्निंग (AutoML) के क्लासिफ़िकेशन मॉडल को ट्रेनिंग देती है, उसका आकलन करती है, और उसे डिप्लॉय करती है
Vertex AI की सेवाओं के साथ इंटरैक्ट करने के लिए, पहले से बने कॉम्पोनेंट इस्तेमाल करें. ये कॉम्पोनेंट, google_cloud_pipeline_components लाइब्रेरी के ज़रिए उपलब्ध कराए जाते हैं
Cloud Scheduler की मदद से, पाइपलाइन जॉब शेड्यूल करना

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

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

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

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

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

अगर आपका कोई सुझाव, शिकायत या राय है, तो कृपया सहायता पेज पर जाएं.

एमएल पाइपलाइन क्यों काम की हैं?

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

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

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

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

पहला चरण: Cloud Shell को शुरू करना

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

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

Cloud Shell चालू करें

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

Cloud Shell चालू करें

अगर आपने पहले कभी Cloud Shell का इस्तेमाल नहीं किया है, तो आपको एक इंटरमीडियरी स्क्रीन (फ़ोल्ड के नीचे) दिखेगी. इसमें 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  \
                       cloudbuild.googleapis.com \
                       cloudfunctions.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 इंस्टेंस

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

पांचवां चरण: अपना नोटबुक खोलना

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

Notebook खोलें

4. Vertex Pipelines का सेटअप

Vertex Pipelines का इस्तेमाल करने के लिए, हमें कुछ और लाइब्रेरी इंस्टॉल करनी होंगी:

Kubeflow Pipelines: इस SDK टूल का इस्तेमाल करके, हम अपनी पाइपलाइन बनाएंगे. Vertex Pipelines, Kubeflow Pipelines या TFX दोनों के साथ बनाई गई चलाने वाली पाइपलाइन के साथ काम करता है.
Google Cloud के पाइपलाइन कॉम्पोनेंट: इस लाइब्रेरी में पहले से बने कॉम्पोनेंट मिलते हैं. इनकी मदद से, पाइपलाइन स्टेप में Vertex AI की सेवाओं के साथ आसानी से इंटरैक्ट किया जा सकता है.

पहला चरण: Python नोटबुक बनाना और लाइब्रेरी इंस्टॉल करना

सबसे पहले, अपने Notebook इंस्टेंस के लॉन्चर मेन्यू में जाकर, Python 3 चुनकर कोई नोटबुक बनाएं:

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

अपने नोटबुक इंस्टेंस के सबसे ऊपर बाईं ओर मौजूद, + साइन पर क्लिक करके, लॉन्चर मेन्यू को ऐक्सेस किया जा सकता है.

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

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"

चरण 3: लाइब्रेरी इंपोर्ट करें

इस कोडलैब में इस्तेमाल की जाने वाली लाइब्रेरी इंपोर्ट करने के लिए, ये जोड़ें:

import kfp

from kfp.v2 import compiler, dsl
from kfp.v2.dsl import component, pipeline, Artifact, ClassificationMetrics, Input, Output, Model, Metrics

from google.cloud import aiplatform
from google_cloud_pipeline_components import aiplatform as gcc_aip
from typing import NamedTuple

चौथा चरण: कॉन्स्टेंट तय करना

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

KFP SDK में कस्टम कॉम्पोनेंट बनाने का तरीका
Vertex Pipelines में पाइपलाइन को चलाने और उसकी निगरानी करने का तरीका

हम एक ऐसी पाइपलाइन बनाएंगे जो दो आउटपुट का इस्तेमाल करके वाक्य प्रिंट करती है: प्रॉडक्ट का नाम और इमोजी के ज़रिए दिया गया ब्यौरा. इस पाइपलाइन में तीन कॉम्पोनेंट होंगे:

product_name: यह कॉम्पोनेंट, प्रॉडक्ट का नाम (या कोई ऐसा कोई भी संज्ञा) इनपुट के तौर पर लेगा और उस स्ट्रिंग को आउटपुट के तौर पर दिखाएगा
emoji: यह कॉम्पोनेंट, इमोजी के ब्यौरे में टेक्स्ट को लेता है और उसे इमोजी में बदल देता है. उदाहरण के लिए, ✨ का टेक्स्ट कोड "sparkles" है. यह कॉम्पोनेंट, इमोजी लाइब्रेरी का इस्तेमाल करके, आपको अपनी पाइपलाइन में बाहरी डिपेंडेंसी मैनेज करने का तरीका दिखाता है
build_sentence: यह आखिरी कॉम्पोनेंट पिछले दो नतीजों के आउटपुट का इस्तेमाल करेगा, ताकि इमोजी का इस्तेमाल करके वाक्य बनाया जा सके. उदाहरण के लिए, नतीजा "Vertex Pipelines is ✨" हो सकता है.

आइए, कोडिंग शुरू करते हैं!

पहला चरण: Python फ़ंक्शन के आधार पर कॉम्पोनेंट बनाना

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

@component(base_image="python:3.9", output_component_file="first-component.yaml")
def product_name(text: str) -> str:
    return text

आइए, यहां सिंटैक्स के बारे में ज़्यादा जानते हैं:

पाइपलाइन चलने पर, @component डेकोरेटर इस फ़ंक्शन को कॉम्पोनेंट में कंपाइल करता है. जब भी कोई कस्टम कॉम्पोनेंट लिखा जाएगा, तो आपको इसका इस्तेमाल करना होगा.
base_image पैरामीटर से उस कंटेनर इमेज के बारे में पता चलता है जिसका इस्तेमाल यह कॉम्पोनेंट करेगा.
output_component_file पैरामीटर का इस्तेमाल करना ज़रूरी नहीं है. यह पैरामीटर, इकट्ठा किए गए कॉम्पोनेंट को लिखने के लिए yaml फ़ाइल के बारे में बताता है. सेल को चलाने के बाद, आपको वह फ़ाइल अपने नोटबुक इंस्टेंस में दिखेगी. अगर आपको इस कॉम्पोनेंट को किसी के साथ शेयर करना है, तो जनरेट की गई yaml फ़ाइल भेजें और उसे इनके साथ लोड करें:

product_name_component = kfp.components.load_component_from_file('./first-component.yaml')

फ़ंक्शन की परिभाषा के बाद मौजूद -> str, इस कॉम्पोनेंट के लिए आउटपुट टाइप तय करता है.

दूसरा चरण: दो और कॉम्पोनेंट बनाना

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

@component(packages_to_install=["emoji"])
def emoji(
    text: str,
) -> NamedTuple(
    "Outputs",
    [
        ("emoji_text", str),  # Return parameters
        ("emoji", str),
    ],
):
    import emoji

    emoji_text = text
    emoji_str = emoji.emojize(':' + emoji_text + ':', language='alias')
    print("output one: {}; output_two: {}".format(emoji_text, emoji_str))
    return (emoji_text, emoji_str)

यह कॉम्पोनेंट, हमारे पिछले कॉम्पोनेंट से थोड़ा ज़्यादा जटिल है. आइए, इन नई सुविधाओं के बारे में ज़्यादा जानें:

packages_to_install पैरामीटर, इस कंटेनर के लिए कॉम्पोनेंट को किसी बाहरी लाइब्रेरी डिपेंडेंसी के बारे में बताता है. इस मामले में, हम इमोजी नाम की लाइब्रेरी का इस्तेमाल कर रहे हैं.
यह कॉम्पोनेंट, Outputs नाम का NamedTuple दिखाता है. ध्यान दें कि इस ट्यूपल में मौजूद हर स्ट्रिंग में ये कुंजियां हैं: emoji_text और emoji. हम आउटपुट ऐक्सेस करने के लिए, अपने अगले कॉम्पोनेंट में इनका इस्तेमाल करेंगे.

इस पाइपलाइन में मौजूद आखिरी कॉम्पोनेंट, पहले दो कॉम्पोनेंट के आउटपुट का इस्तेमाल करेगा और उन्हें स्ट्रिंग दिखाने के लिए जोड़ देगा:

@component
def build_sentence(
    product: str,
    emoji: str,
    emojitext: str
) -> str:
    print("We completed the pipeline, hooray!")
    end_str = product + " is "
    if len(emoji) > 0:
        end_str += emoji
    else:
        end_str += emojitext
    return(end_str)

शायद आप सोच रहे हों कि यह कॉम्पोनेंट, आपके तय किए गए पिछले चरणों के आउटपुट का इस्तेमाल कैसे करता है? अच्छा सवाल है! अगले चरण में, हम इन सभी को एक साथ जोड़ देंगे.

तीसरा चरण: कॉम्पोनेंट को एक साथ पाइपलाइन में डालना

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

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

product_task, प्रॉडक्ट का नाम इनपुट के तौर पर लेता है. हम "Vertex Pipelines" पास कर रहे हैं, लेकिन आप इसे अपनी पसंद के मुताबिक बदल सकते हैं.
emoji_task, किसी इमोजी के टेक्स्ट कोड को इनपुट के तौर पर लेता है. इसे अपनी पसंद के मुताबिक भी बदला जा सकता है. उदाहरण के लिए, "party_face" का मतलब 🥳 इमोजी से है. ध्यान दें कि इस और product_task कॉम्पोनेंट, दोनों में कोई ऐसा चरण नहीं है जो इनमें इनपुट डालता हो. इसलिए, अपनी पाइपलाइन तय करते समय, हम इनके लिए मैन्युअल रूप से इनपुट तय करते हैं.
हमारी पाइपलाइन के आखिरी चरण - consumer_task में तीन इनपुट पैरामीटर हैं:
- product_task का आउटपुट. इस चरण से सिर्फ़ एक आउटपुट मिलता है. इसलिए, हम इसका रेफ़रंस product_task.output के ज़रिए दे सकते हैं.
- emoji_task चरण का emoji आउटपुट. ऊपर तय किया गया emoji कॉम्पोनेंट देखें जहां हमने आउटपुट पैरामीटर को नाम दिया है.
- इसी तरह, emoji_text नाम वाला आउटपुट, emoji कॉम्पोनेंट से मिलता है. अगर हमारी पाइपलाइन में ऐसा टेक्स्ट पास किया जाता है जो इमोजी से मेल नहीं खाता, तो इस टेक्स्ट का इस्तेमाल वाक्य बनाने में किया जाएगा.

@pipeline(
    name="hello-world",
    description="An intro pipeline",
    pipeline_root=PIPELINE_ROOT,
)

# You can change the `text` and `emoji_str` parameters here to update the pipeline output
def intro_pipeline(text: str = "Vertex Pipelines", emoji_str: str = "sparkles"):
    product_task = product_name(text)
    emoji_task = emoji(emoji_str)
    consumer_task = build_sentence(
        product_task.output,
        emoji_task.outputs["emoji"],
        emoji_task.outputs["emoji_text"],
    )

चौथा चरण: पाइपलाइन को कंपाइल और चलाना

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

compiler.Compiler().compile(
    pipeline_func=intro_pipeline, package_path="intro_pipeline_job.json"
)

इसके बाद, TIMESTAMP वैरिएबल बनाएं. हम इसका इस्तेमाल अपने जॉब आईडी में करेंगे:

from datetime import datetime

TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")

इसके बाद, अपनी पाइपलाइन जॉब तय करें:

job = aiplatform.PipelineJob(
    display_name="hello-world-pipeline",
    template_path="intro_pipeline_job.json",
    job_id="hello-world-pipeline-{0}".format(TIMESTAMP),
    enable_caching=True
)

आखिर में, नई पाइपलाइन एक्सीक्यूशन बनाने के लिए जॉब चलाएं:

job.submit()

इस सेल को चलाने के बाद, आपको अपने कंसोल में रन की गई पाइपलाइन देखने के लिए, लिंक के साथ लॉग दिखेंगे:

पाइपलाइन जॉब लॉग

उस लिंक पर जाएं. पूरी होने के बाद, आपकी पाइपलाइन कुछ इस तरह दिखेगी:

इस पाइपलाइन को चलने में 5 से 6 मिनट लगेंगे. पूरा होने के बाद, build-sentence कॉम्पोनेंट पर क्लिक करके फ़ाइनल आउटपुट देखा जा सकता है:

इंट्रो पाइपलाइन का आउटपुट

KFP SDK और Vertex Pipelines के काम करने के तरीके के बारे में जानने के बाद, अब आप एक ऐसी पाइपलाइन बनाने के लिए तैयार हैं जो Vertex AI की अन्य सेवाओं का इस्तेमाल करके एमएल मॉडल बनाती है और उसे डिप्लॉय करती है. आइए, शुरू करते हैं!

6. एंड-टू-एंड एमएल पाइपलाइन बनाना

अपनी पहली एमएल पाइपलाइन बनाने का समय आ गया है. इस पाइपलाइन में, हम UCI मशीन लर्निंग ड्राई बीन्स डेटासेट का इस्तेमाल करेंगे. यह डेटासेट, KOKLU, M. और OZKAN, I.A. से लिया गया है. (2020), "कंप्यूटर विज़न और मशीन लर्निंग तकनीकों का इस्तेमाल करके, सूखी फ़ली की अलग-अलग कैटगरी में बांटना."In Computers and Electronics in Agriculture, 174, 105507. DOI.

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

यह पाइपलाइन:

में डेटासेट बनाएं
AutoML की मदद से, टेबल के तौर पर डेटा को अलग-अलग कैटगरी में बांटने वाले मॉडल को ट्रेन करना
इस मॉडल के लिए, आकलन की मेट्रिक पाना
जांच की मेट्रिक के आधार पर, यह तय करें कि Vertex Pipelines में शर्तों के लॉजिक का इस्तेमाल करके मॉडल को डिप्लॉय करना है या नहीं
Vertex Prediction का इस्तेमाल करके, मॉडल को एंडपॉइंट पर डिप्लॉय करना

यहां बताए गए हर चरण को एक कॉम्पोनेंट माना जाएगा. पाइपलाइन के ज़्यादातर चरणों में, Vertex AI की सेवाओं के लिए पहले से बने कॉम्पोनेंट का इस्तेमाल किया जाएगा. इसके लिए, कोडलैब में पहले से इंपोर्ट की गई google_cloud_pipeline_components लाइब्रेरी का इस्तेमाल किया जाएगा. इस सेक्शन में, हम सबसे पहले एक कस्टम कॉम्पोनेंट तय करेंगे. इसके बाद, हम पहले से बने कॉम्पोनेंट का इस्तेमाल करके, पाइपलाइन के बाकी चरणों को तय करेंगे. पहले से बने कॉम्पोनेंट की मदद से, Vertex AI की सेवाओं को आसानी से ऐक्सेस किया जा सकता है. जैसे, मॉडल को ट्रेनिंग देना और डिप्लॉय करना.

पहला चरण: मॉडल इवैलुएशन के लिए एक कस्टम कॉम्पोनेंट

मॉडल की ट्रेनिंग पूरी होने के बाद, हम जिस कस्टम कॉम्पोनेंट को तय करेंगे उसका इस्तेमाल हमारी पाइपलाइन के आखिर में किया जाएगा. यह कॉम्पोनेंट कुछ काम करेगा:

आकलन की मेट्रिक पाने के लिए, ट्रेन किए गए AutoML क्लासिफ़िकेशन मॉडल की मदद लें
मेट्रिक को पार्स करें और उन्हें Vertex Pipelines यूज़र इंटरफ़ेस (यूआई) में रेंडर करें
मेट्रिक की तुलना थ्रेशोल्ड से करें, ताकि यह तय किया जा सके कि मॉडल को डिप्लॉय किया जाना चाहिए या नहीं

कॉम्पोनेंट के बारे में बताने से पहले, आइए इसके इनपुट और आउटपुट पैरामीटर के बारे में जानें. इनपुट के तौर पर, यह पाइपलाइन हमारे Cloud प्रोजेक्ट का कुछ मेटाडेटा, ट्रेन किया गया मॉडल (हम इस कॉम्पोनेंट के बारे में बाद में बताएंगे), मॉडल की आकलन मेट्रिक, और thresholds_dict_str लेती है. thresholds_dict_str के बारे में हम अपनी पाइपलाइन चलाते समय बताएंगे. इस क्लासिफ़िकेशन मॉडल के मामले में, यह आरओसी कर्व वैल्यू के तहत आने वाला एरिया होगा, जिसके लिए हमें मॉडल को डिप्लॉय करना चाहिए. उदाहरण के लिए, अगर हम 0.95 डालते हैं, तो इसका मतलब है कि हम चाहेंगे कि हमारी पाइपलाइन, मॉडल को सिर्फ़ तब डिप्लॉय करे, जब यह मेट्रिक 95% से ज़्यादा हो.

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

@component(
    base_image="gcr.io/deeplearning-platform-release/tf2-cpu.2-3:latest",
    output_component_file="tabular_eval_component.yaml",
    packages_to_install=["google-cloud-aiplatform"],
)
def classification_model_eval_metrics(
    project: str,
    location: str,  # "us-central1",
    api_endpoint: str,  # "us-central1-aiplatform.googleapis.com",
    thresholds_dict_str: str,
    model: Input[Artifact],
    metrics: Output[Metrics],
    metricsc: Output[ClassificationMetrics],
) -> NamedTuple("Outputs", [("dep_decision", str)]):  # Return parameter.

    import json
    import logging

    from google.cloud import aiplatform as aip

    # Fetch model eval info
    def get_eval_info(client, model_name):
        from google.protobuf.json_format import MessageToDict

        response = client.list_model_evaluations(parent=model_name)
        metrics_list = []
        metrics_string_list = []
        for evaluation in response:
            print("model_evaluation")
            print(" name:", evaluation.name)
            print(" metrics_schema_uri:", evaluation.metrics_schema_uri)
            metrics = MessageToDict(evaluation._pb.metrics)
            for metric in metrics.keys():
                logging.info("metric: %s, value: %s", metric, metrics[metric])
            metrics_str = json.dumps(metrics)
            metrics_list.append(metrics)
            metrics_string_list.append(metrics_str)

        return (
            evaluation.name,
            metrics_list,
            metrics_string_list,
        )

    # Use the given metrics threshold(s) to determine whether the model is
    # accurate enough to deploy.
    def classification_thresholds_check(metrics_dict, thresholds_dict):
        for k, v in thresholds_dict.items():
            logging.info("k {}, v {}".format(k, v))
            if k in ["auRoc", "auPrc"]:  # higher is better
                if metrics_dict[k] < v:  # if under threshold, don't deploy
                    logging.info("{} < {}; returning False".format(metrics_dict[k], v))
                    return False
        logging.info("threshold checks passed.")
        return True

    def log_metrics(metrics_list, metricsc):
        test_confusion_matrix = metrics_list[0]["confusionMatrix"]
        logging.info("rows: %s", test_confusion_matrix["rows"])

        # log the ROC curve
        fpr = []
        tpr = []
        thresholds = []
        for item in metrics_list[0]["confidenceMetrics"]:
            fpr.append(item.get("falsePositiveRate", 0.0))
            tpr.append(item.get("recall", 0.0))
            thresholds.append(item.get("confidenceThreshold", 0.0))
        print(f"fpr: {fpr}")
        print(f"tpr: {tpr}")
        print(f"thresholds: {thresholds}")
        metricsc.log_roc_curve(fpr, tpr, thresholds)

        # log the confusion matrix
        annotations = []
        for item in test_confusion_matrix["annotationSpecs"]:
            annotations.append(item["displayName"])
        logging.info("confusion matrix annotations: %s", annotations)
        metricsc.log_confusion_matrix(
            annotations,
            test_confusion_matrix["rows"],
        )

        # log textual metrics info as well
        for metric in metrics_list[0].keys():
            if metric != "confidenceMetrics":
                val_string = json.dumps(metrics_list[0][metric])
                metrics.log_metric(metric, val_string)
        # metrics.metadata["model_type"] = "AutoML Tabular classification"

    logging.getLogger().setLevel(logging.INFO)
    aip.init(project=project)
    # extract the model resource name from the input Model Artifact
    model_resource_path = model.metadata["resourceName"]
    logging.info("model path: %s", model_resource_path)

    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    client = aip.gapic.ModelServiceClient(client_options=client_options)
    eval_name, metrics_list, metrics_str_list = get_eval_info(
        client, model_resource_path
    )
    logging.info("got evaluation name: %s", eval_name)
    logging.info("got metrics list: %s", metrics_list)
    log_metrics(metrics_list, metricsc)

    thresholds_dict = json.loads(thresholds_dict_str)
    deploy = classification_thresholds_check(metrics_list[0], thresholds_dict)
    if deploy:
        dep_decision = "true"
    else:
        dep_decision = "false"
    logging.info("deployment decision is %s", dep_decision)

    return (dep_decision,)

दूसरा चरण: Google Cloud में पहले से बने कॉम्पोनेंट जोड़ना

इस चरण में, हम अपनी पाइपलाइन के बाकी कॉम्पोनेंट तय करेंगे और देखेंगे कि वे सभी एक साथ कैसे काम करते हैं. सबसे पहले, टाइमस्टैंप का इस्तेमाल करके अपनी पाइपलाइन के रन के लिए डिसप्ले नेम तय करें:

import time
DISPLAY_NAME = 'automl-beans{}'.format(str(int(time.time())))
print(DISPLAY_NAME)

इसके बाद, नीचे दिए गए कोड को किसी नई नोटबुक सेल में कॉपी करें:

@pipeline(name="automl-tab-beans-training-v2",
                  pipeline_root=PIPELINE_ROOT)
def pipeline(
    bq_source: str = "bq://aju-dev-demos.beans.beans1",
    display_name: str = DISPLAY_NAME,
    project: str = PROJECT_ID,
    gcp_region: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
    thresholds_dict_str: str = '{"auRoc": 0.95}',
):
    dataset_create_op = gcc_aip.TabularDatasetCreateOp(
        project=project, display_name=display_name, bq_source=bq_source
    )

    training_op = gcc_aip.AutoMLTabularTrainingJobRunOp(
        project=project,
        display_name=display_name,
        optimization_prediction_type="classification",
        budget_milli_node_hours=1000,
        column_transformations=[
            {"numeric": {"column_name": "Area"}},
            {"numeric": {"column_name": "Perimeter"}},
            {"numeric": {"column_name": "MajorAxisLength"}},
            {"numeric": {"column_name": "MinorAxisLength"}},
            {"numeric": {"column_name": "AspectRation"}},
            {"numeric": {"column_name": "Eccentricity"}},
            {"numeric": {"column_name": "ConvexArea"}},
            {"numeric": {"column_name": "EquivDiameter"}},
            {"numeric": {"column_name": "Extent"}},
            {"numeric": {"column_name": "Solidity"}},
            {"numeric": {"column_name": "roundness"}},
            {"numeric": {"column_name": "Compactness"}},
            {"numeric": {"column_name": "ShapeFactor1"}},
            {"numeric": {"column_name": "ShapeFactor2"}},
            {"numeric": {"column_name": "ShapeFactor3"}},
            {"numeric": {"column_name": "ShapeFactor4"}},
            {"categorical": {"column_name": "Class"}},
        ],
        dataset=dataset_create_op.outputs["dataset"],
        target_column="Class",
    )
    model_eval_task = classification_model_eval_metrics(
        project,
        gcp_region,
        api_endpoint,
        thresholds_dict_str,
        training_op.outputs["model"],
    )

    with dsl.Condition(
        model_eval_task.outputs["dep_decision"] == "true",
        name="deploy_decision",
    ):

        endpoint_op = gcc_aip.EndpointCreateOp(
            project=project,
            location=gcp_region,
            display_name="train-automl-beans",
        )

        gcc_aip.ModelDeployOp(
            model=training_op.outputs["model"],
            endpoint=endpoint_op.outputs["endpoint"],
            dedicated_resources_min_replica_count=1,
            dedicated_resources_max_replica_count=1,
            dedicated_resources_machine_type="n1-standard-4",
        )

चलिए, देखते हैं कि इस कोड में क्या हो रहा है:

सबसे पहले, हमारी पिछली पाइपलाइन की तरह ही, हम इस पाइपलाइन में इस्तेमाल होने वाले इनपुट पैरामीटर तय करते हैं. हमें इन्हें मैन्युअल रूप से सेट करना होता है, क्योंकि ये पाइपलाइन के अन्य चरणों के आउटपुट पर निर्भर नहीं होते.
Vertex AI की सेवाओं के साथ इंटरैक्ट करने के लिए, बाकी पाइपलाइन में पहले से बने कॉम्पोनेंट का इस्तेमाल किया जाता है:
- TabularDatasetCreateOp, Cloud Storage या BigQuery में मौजूद डेटासेट सोर्स की मदद से, Vertex AI में टेबल वाला डेटासेट बनाता है. इस पाइपलाइन में, हम BigQuery टेबल के यूआरएल के ज़रिए डेटा पास कर रहे हैं
- AutoMLTabularTrainingJobRunOp, टेबल वाले डेटासेट के लिए AutoML ट्रेनिंग जॉब शुरू करता है. हम इस कॉम्पोनेंट में कुछ कॉन्फ़िगरेशन पैरामीटर पास करते हैं. इनमें मॉडल टाइप (इस मामले में, क्लासिफ़िकेशन), कॉलम का कुछ डेटा, ट्रेनिंग कितनी देर तक चलानी है, और डेटासेट का पॉइंटर शामिल है. ध्यान दें कि इस कॉम्पोनेंट में डेटासेट को पास करने के लिए, हम dataset_create_op.outputs["dataset"] के ज़रिए पिछले कॉम्पोनेंट का आउटपुट दे रहे हैं
- EndpointCreateOp, Vertex AI में एंडपॉइंट बनाता है. इस चरण में बनाया गया एंडपॉइंट, अगले कॉम्पोनेंट को इनपुट के तौर पर पास किया जाएगा
- ModelDeployOp, Vertex AI में किसी एंडपॉइंट पर मॉडल को डिप्लॉय करता है. इस मामले में, हम पिछले चरण में बनाए गए एंडपॉइंट का इस्तेमाल कर रहे हैं. कॉन्फ़िगरेशन के अन्य विकल्प भी उपलब्ध हैं. हालांकि, यहां हम एंडपॉइंट मशीन का वह टाइप और मॉडल दे रहे हैं जिसे हमें डिप्लॉय करना है. हम अपनी पाइपलाइन में ट्रेनिंग चरण के आउटपुट को ऐक्सेस करके, मॉडल को पास कर रहे हैं
इस पाइपलाइन में शर्त के हिसाब से लॉजिक का भी इस्तेमाल किया गया है. यह Vertex पाइपलाइन की एक सुविधा है. इसकी मदद से, किसी शर्त के साथ-साथ उस शर्त के नतीजे के आधार पर अलग-अलग शाखाएं तय की जा सकती हैं. याद रखें कि हमने अपनी पाइपलाइन तय करते समय, thresholds_dict_str पैरामीटर पास किया था. सटीक होने की यह सीमा, हम यह तय करने के लिए इस्तेमाल कर रहे हैं कि हमारे मॉडल को एंडपॉइंट पर डिप्लॉय करना है या नहीं. इसे लागू करने के लिए, हम KFP SDK की Condition क्लास का इस्तेमाल करते हैं. हमने जो शर्त दी है वह इस कोडलैब में पहले बताए गए कस्टम eval कॉम्पोनेंट का आउटपुट है. अगर यह शर्त पूरी होती है, तो पाइपलाइन deploy_op कॉम्पोनेंट को लागू करती रहेगी. अगर सटीकता, पहले से तय किए गए थ्रेशोल्ड के मुताबिक नहीं है, तो पाइपलाइन यहां रुक जाएगी और कोई मॉडल डिप्लॉय नहीं किया जाएगा.

तीसरा चरण: एंड-टू-एंड एमएल पाइपलाइन को कंपाइल और चलाना

पूरी पाइपलाइन तय करने के बाद, उसे कंपाइल करने का समय आ गया है:

compiler.Compiler().compile(
    pipeline_func=pipeline, package_path="tab_classif_pipeline.json"
)

इसके बाद, नौकरी की जानकारी दें:

ml_pipeline_job = aiplatform.PipelineJob(
    display_name="automl-tab-beans-training",
    template_path="tab_classif_pipeline.json",
    pipeline_root=PIPELINE_ROOT,
    parameter_values={"project": PROJECT_ID, "display_name": DISPLAY_NAME},
    enable_caching=True
)

आखिर में, जॉब चलाएं:

ml_pipeline_job.submit()

कंसोल में अपनी पाइपलाइन देखने के लिए, ऊपर दिए गए सेल को चलाने के बाद, लॉग में दिखाए गए लिंक पर जाएं. इस पाइपलाइन को चलने में एक घंटे से ज़्यादा समय लगेगा. ज़्यादातर समय, AutoML ट्रेनिंग चरण में बीतता है. पूरी की गई पाइपलाइन कुछ इस तरह दिखेगी:

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

सबसे ऊपर मौजूद "आर्टफ़ैक्ट बड़ा करें" बटन को टॉगल करने पर, आपको अपनी पाइपलाइन से बनाए गए अलग-अलग आर्टफ़ैक्ट की जानकारी दिखेगी. उदाहरण के लिए, dataset आर्टफ़ैक्ट पर क्लिक करने पर, आपको बनाए गए Vertex AI डेटासेट की जानकारी दिखेगी. उस डेटासेट के पेज पर जाने के लिए, यहां दिए गए लिंक पर क्लिक करें:

पाइपलाइन डेटासेट

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

मेट्रिक का विज़ुअलाइज़ेशन

इस पाइपलाइन से बनाए गए मॉडल और एंडपॉइंट देखने के लिए, मॉडल सेक्शन पर जाएं और automl-beans नाम के मॉडल पर क्लिक करें. वहां आपको यह मॉडल, एंडपॉइंट पर डिप्लॉय किया हुआ दिखेगा:

Model-endpoint

अपने पाइपलाइन ग्राफ़ में एंडपॉइंट आर्टफ़ैक्ट पर क्लिक करके भी इस पेज को ऐक्सेस किया जा सकता है.

कंसोल में पाइपलाइन ग्राफ़ देखने के अलावा, लाइनेज ट्रैकिंग के लिए भी वर्टिक्स पाइपलाइन का इस्तेमाल किया जा सकता है. लाइनेज ट्रैकिंग का मतलब है, आपकी पूरी पाइपलाइन में बनाए गए आर्टफ़ैक्ट को ट्रैक करना. इससे हमें यह समझने में मदद मिलती है कि आर्टफ़ैक्ट कहां बनाए गए थे और एमएल वर्कफ़्लो में उनका इस्तेमाल कैसे किया जा रहा है. उदाहरण के लिए, इस पाइपलाइन में बनाए गए डेटासेट के लिए, लीनेज ट्रैकिंग देखने के लिए, डेटासेट आर्टफ़ैक्ट पर क्लिक करें. इसके बाद, लीनेज देखें पर क्लिक करें:

लीनिएज देखें

इससे हमें वे सभी जगहें दिखती हैं जहां इस आर्टफ़ैक्ट का इस्तेमाल किया जा रहा है:

लाइनेज की जानकारी

चौथा चरण: अलग-अलग पाइपलाइन रन की मेट्रिक की तुलना करना

अगर इस पाइपलाइन को कई बार चलाया जाता है, तो हो सकता है कि आप अलग-अलग रन की मेट्रिक की तुलना करना चाहें. रन मेटाडेटा को ऐक्सेस करने के लिए, aiplatform.get_pipeline_df() तरीके का इस्तेमाल किया जा सकता है. यहां, हमें इस पाइपलाइन के सभी रन का मेटाडेटा मिलेगा और हम उसे Pandas DataFrame में लोड करेंगे:

pipeline_df = aiplatform.get_pipeline_df(pipeline="automl-tab-beans-training-v2")
small_pipeline_df = pipeline_df.head(2)
small_pipeline_df

इस तरह, लैब की प्रोसेस पूरी हो गई!

🎉 बधाई हो! 🎉

आपने Vertex AI को इस्तेमाल करने का तरीका जान लिया है, ताकि:

कस्टम कॉम्पोनेंट के साथ एंड-टू-एंड पाइपलाइन बनाने के लिए, Kubeflow Pipelines SDK का इस्तेमाल करना
Vertex Pipelines पर अपनी पाइपलाइन चलाएं और SDK टूल की मदद से पाइपलाइन चलाना शुरू करें
कंसोल में अपने Vertex Pipelines ग्राफ़ को देखना और उसका विश्लेषण करना
अपनी पाइपलाइन में Vertex AI की सेवाएं जोड़ने के लिए, पहले से बने पाइपलाइन कॉम्पोनेंट का इस्तेमाल करें
बार-बार होने वाले पाइपलाइन जॉब शेड्यूल करना

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

7. साफ़-सफ़ाई सेवा

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

पहला चरण: Notebooks इंस्टेंस को रोकना या मिटाना

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

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

दूसरा चरण: अपना एंडपॉइंट मिटाना

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

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

इसके बाद, नीचे दिए गए प्रॉम्प्ट में अनडिप्लॉय करें पर क्लिक करें:

मॉडल को अनडिप्लॉय करना

आखिर में, अपने कंसोल के मॉडल सेक्शन पर जाएं और उस मॉडल को ढूंढें. इसके बाद, दाईं ओर मौजूद तीन बिंदु वाले मेन्यू में जाकर, मॉडल मिटाएं पर क्लिक करें:

मॉडल मिटाना

तीसरा चरण: Cloud Storage बकेट को मिटाना

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

स्टोरेज मिटाना