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 के सभी प्रॉडक्ट ऑफ़रिंग देखी जा सकती हैं.
अगर आपको कोई सुझाव देना है या शिकायत करनी है, तो कृपया सहायता पेज पर जाएं.
मशीन लर्निंग पाइपलाइन क्यों काम की होती हैं?
इससे पहले कि हम आगे बढ़ें, आइए पहले यह समझते हैं कि आपको पाइपलाइन का इस्तेमाल क्यों करना चाहिए. मान लें कि आपको एक ऐसा एमएल वर्कफ़्लो बनाना है जिसमें डेटा को प्रोसेस करना, मॉडल को ट्रेन करना, हाइपरपैरामीटर ट्यूनिंग, आकलन, और मॉडल डिप्लॉयमेंट शामिल हो. इनमें से हर चरण की अलग-अलग डिपेंडेंसी हो सकती हैं. अगर पूरे वर्कफ़्लो को एक ही यूनिट के तौर पर माना जाता है, तो यह मुश्किल हो सकता है. एमएल प्रोसेस को बड़ा करने के लिए, आपको अपनी टीम के अन्य सदस्यों के साथ एमएल वर्कफ़्लो शेयर करना पड़ सकता है. इससे वे इसे चला पाएंगे और कोड में योगदान दे पाएंगे. भरोसेमंद और दोहराई जा सकने वाली प्रोसेस के बिना, यह मुश्किल हो सकता है. पाइपलाइन की मदद से, एमएल प्रोसेस का हर चरण एक अलग कंटेनर होता है. इससे, चरणों को अलग-अलग तरीके से डेवलप किया जा सकता है. साथ ही, हर चरण के इनपुट और आउटपुट को इस तरह से ट्रैक किया जा सकता है कि उसे दोहराया जा सके. आपके पास Cloud एनवायरमेंट में मौजूद अन्य इवेंट के आधार पर, अपनी पाइपलाइन के रन को शेड्यूल करने या ट्रिगर करने का विकल्प भी होता है. जैसे, नया ट्रेनिंग डेटा उपलब्ध होने पर पाइपलाइन रन शुरू करना.
संक्षेप में जानकारी: पाइपलाइन की मदद से, एमएल वर्कफ़्लो को ऑटोमेट और दोबारा बनाया जा सकता है.
3. क्लाउड एनवायरमेंट सेटअप करना
इस कोडलैब को चलाने के लिए, आपके पास बिलिंग की सुविधा वाला Google Cloud Platform प्रोजेक्ट होना चाहिए. प्रोजेक्ट बनाने के लिए, यहां दिए गए निर्देशों का पालन करें.
पहला चरण: Cloud Shell शुरू करना
इस लैब में, आपको Cloud Shell सेशन में काम करना होगा. यह एक कमांड इंटरप्रेटर है, जिसे Google के क्लाउड में चल रही वर्चुअल मशीन होस्ट करती है. इस सेक्शन को अपने कंप्यूटर पर भी आसानी से चलाया जा सकता है. हालांकि, Cloud Shell का इस्तेमाल करने से, सभी लोगों को एक जैसे एनवायरमेंट में एक जैसा अनुभव मिलता है. लैब के बाद, अपने कंप्यूटर पर इस सेक्शन को फिर से आज़माया जा सकता है.
Cloud Shell चालू करें
Cloud Console में सबसे ऊपर दाईं ओर, Cloud Shell चालू करें के लिए, नीचे दिए गए बटन पर क्लिक करें:
अगर आपने पहले कभी Cloud Shell का इस्तेमाल नहीं किया है, तो आपको एक इंटरमीडिएट स्क्रीन (नीचे फ़ोल्ड की गई) दिखेगी. इसमें Cloud Shell के बारे में जानकारी दी गई होगी. अगर ऐसा है, तो जारी रखें पर क्लिक करें. इसके बाद, आपको यह स्क्रीन कभी नहीं दिखेगी. एक बार दिखने वाली स्क्रीन ऐसी दिखती है:
Cloud Shell से कनेक्ट होने में कुछ ही सेकंड लगेंगे.
इस वर्चुअल मशीन में, डेवलपमेंट के लिए ज़रूरी सभी टूल पहले से मौजूद होते हैं. यह 5 जीबी की होम डायरेक्ट्री उपलब्ध कराता है और Google Cloud में चलता है. इससे नेटवर्क की परफ़ॉर्मेंस और पुष्टि करने की प्रोसेस बेहतर होती है. इस कोडलैब में ज़्यादातर काम, सिर्फ़ ब्राउज़र या Chromebook की मदद से किया जा सकता है.
Cloud Shell से कनेक्ट होने के बाद, आपको दिखेगा कि आपकी पुष्टि पहले ही हो चुकी है और प्रोजेक्ट को आपके प्रोजेक्ट आईडी पर पहले ही सेट कर दिया गया है.
पुष्टि करें कि आपने Cloud Shell में पुष्टि कर ली है. इसके लिए, यह कमांड चलाएं:
gcloud auth list
आपको कमांड के आउटपुट में कुछ ऐसा दिखेगा:
यह पुष्टि करने के लिए कि gcloud कमांड को आपके प्रोजेक्ट के बारे में पता है, Cloud Shell में यह कमांड चलाएं:
gcloud config list project
कमांड आउटपुट
[core] project = <PROJECT_ID>
अगर ऐसा नहीं है, तो इस कमांड का इस्तेमाल करके इसे सेट किया जा सकता है:
gcloud config set project <PROJECT_ID>
कमांड आउटपुट
Updated property [core/project].
Cloud Shell में कुछ एनवायरमेंट वैरिएबल होते हैं. इनमें GOOGLE_CLOUD_PROJECT भी शामिल है. इसमें हमारे मौजूदा Cloud प्रोजेक्ट का नाम होता है. हम इसका इस्तेमाल इस लैब में कई जगहों पर करेंगे. इसे चलाने पर आपको यह दिखेगा:
echo $GOOGLE_CLOUD_PROJECT
दूसरा चरण: एपीआई चालू करना
बाद के चरणों में, आपको पता चलेगा कि इन सेवाओं की ज़रूरत कहां है और क्यों. हालांकि, फ़िलहाल इस कमांड को चलाकर, अपने प्रोजेक्ट को Compute Engine, Container Registry, और Vertex AI सेवाओं का ऐक्सेस दें:
gcloud services enable compute.googleapis.com \
containerregistry.googleapis.com \
aiplatform.googleapis.com \
cloudbuild.googleapis.com \
cloudfunctions.googleapis.com
इससे, इस तरह का मैसेज दिखेगा:
Operation "operations/acf.cc11852d-40af-47ad-9d59-477a12847c9e" finished successfully.
तीसरा चरण: Cloud Storage बकेट बनाना
Vertex AI पर ट्रेनिंग का काम करने के लिए, हमें एक स्टोरेज बकेट की ज़रूरत होगी. इसमें हम सेव की गई मॉडल ऐसेट को सेव करेंगे. बकेट, देश/इलाके के हिसाब से होनी चाहिए. हम यहां us-central का इस्तेमाल कर रहे हैं. हालांकि, आपके पास किसी दूसरे क्षेत्र का इस्तेमाल करने का विकल्प है. इसके लिए, आपको इस लैब में मौजूद us-central को बदलना होगा. अगर आपके पास पहले से ही कोई बकेट है, तो इस चरण को छोड़ा जा सकता है.
बकेट बनाने के लिए, Cloud Shell टर्मिनल में ये कमांड चलाएं:
BUCKET_NAME=gs://$GOOGLE_CLOUD_PROJECT-bucket
gsutil mb -l us-central1 $BUCKET_NAME
इसके बाद, हम अपने कंप्यूट सेवा खाते को इस बकेट का ऐक्सेस देंगे. इससे यह पक्का किया जा सकेगा कि Vertex Pipelines के पास इस बकेट में फ़ाइलें लिखने की ज़रूरी अनुमतियां हैं. यह अनुमति जोड़ने के लिए, यह कमांड चलाएं:
gcloud projects describe $GOOGLE_CLOUD_PROJECT > project-info.txt
PROJECT_NUM=$(cat project-info.txt | sed -nre 's:.*projectNumber\: (.*):\1:p')
SVC_ACCOUNT="${PROJECT_NUM//\'/}-compute@developer.gserviceaccount.com"
gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT --member serviceAccount:$SVC_ACCOUNT --role roles/storage.objectAdmin
चौथा चरण: Vertex AI Workbench इंस्टेंस बनाना
Cloud Console के Vertex AI सेक्शन में जाकर, Workbench पर क्लिक करें:
इसके बाद, उपयोगकर्ता के मैनेज किए गए नोटबुक में जाकर, नई नोटबुक पर क्लिक करें:
इसके बाद, GPU के बिना TensorFlow Enterprise 2.3 (with LTS) इंस्टेंस टाइप चुनें:
डिफ़ॉल्ट विकल्पों का इस्तेमाल करें. इसके बाद, बनाएं पर क्लिक करें.
पांचवां चरण: अपनी नोटबुक खोलें
इंस्टेंस बन जाने के बाद, JupyterLab खोलें को चुनें:
4. Vertex Pipelines का सेटअप
Vertex Pipelines का इस्तेमाल करने के लिए, हमें कुछ और लाइब्रेरी इंस्टॉल करनी होंगी:
- Kubeflow Pipelines: हम इस SDK टूल का इस्तेमाल करके अपनी पाइपलाइन बनाएंगे. Vertex Pipelines, Kubeflow Pipelines या TFX, दोनों की मदद से बनाई गई पाइपलाइन को चलाने की सुविधा देता है.
- Google Cloud Pipeline Components: इस लाइब्रेरी में पहले से बने कॉम्पोनेंट उपलब्ध होते हैं. इनकी मदद से, पाइपलाइन के चरणों से Vertex AI की सेवाओं के साथ आसानी से इंटरैक्ट किया जा सकता है.
पहला चरण: Python नोटबुक बनाना और लाइब्रेरी इंस्टॉल करना
सबसे पहले, अपने Notebook इंस्टेंस में लॉन्चर मेन्यू से, Python 3 को चुनकर एक नोटबुक बनाएं:
नोटबुक इंस्टेंस में सबसे ऊपर बाईं ओर मौजूद + पर क्लिक करके, लॉन्चर मेन्यू को ऐक्सेस किया जा सकता है.
इस लैब में इस्तेमाल की जाने वाली दोनों सेवाओं को इंस्टॉल करने के लिए, पहले नोटबुक सेल में उपयोगकर्ता फ़्लैग सेट करें:
USER_FLAG = "--user"
इसके बाद, अपनी नोटबुक से यह कमांड चलाएं:
!pip3 install {USER_FLAG} google-cloud-aiplatform==1.7.0 --upgrade
!pip3 install {USER_FLAG} kfp==1.8.9 google-cloud-pipeline-components==0.2.0
इन पैकेज को इंस्टॉल करने के बाद, आपको कर्नल को रीस्टार्ट करना होगा:
import os
if not os.getenv("IS_TESTING"):
# Automatically restart kernel after installs
import IPython
app = IPython.Application.instance()
app.kernel.do_shutdown(True)
आखिर में, यह देख लें कि आपने पैकेज सही तरीके से इंस्टॉल किए हों. KFP SDK टूल का वर्शन >=1.8 होना चाहिए:
!python3 -c "import kfp; print('KFP SDK version: {}'.format(kfp.__version__))"
!python3 -c "import google_cloud_pipeline_components; print('google_cloud_pipeline_components version: {}'.format(google_cloud_pipeline_components.__version__))"
दूसरा चरण: अपना प्रोजेक्ट आईडी और बकेट सेट करना
इस लैब में, आपको अपने Cloud प्रोजेक्ट आईडी और पहले बनाए गए बकेट का रेफ़रंस देना होगा. इसके बाद, हम इनमें से हर एक के लिए वैरिएबल बनाएंगे.
अगर आपको अपना प्रोजेक्ट आईडी नहीं पता है, तो इसे पाने के लिए यह कमांड चलाएं:
import os
PROJECT_ID = ""
# Get your Google Cloud project ID from gcloud
if not os.getenv("IS_TESTING"):
shell_output=!gcloud config list --format 'value(core.project)' 2>/dev/null
PROJECT_ID = shell_output[0]
print("Project ID: ", PROJECT_ID)
अगर ऐसा नहीं है, तो इसे यहां सेट करें:
if PROJECT_ID == "" or PROJECT_ID is None:
PROJECT_ID = "your-project-id" # @param {type:"string"}
इसके बाद, बकेट का नाम सेव करने के लिए एक वैरिएबल बनाएं. अगर आपने इसे इस लैब में बनाया है, तो यह तरीका काम करेगा. इसके अलावा, आपको इसे मैन्युअल तरीके से सेट करना होगा:
BUCKET_NAME="gs://" + PROJECT_ID + "-bucket"
तीसरा चरण: लाइब्रेरी इंपोर्ट करना
इस कोडलैब में इस्तेमाल की जाने वाली लाइब्रेरी इंपोर्ट करने के लिए, यह कोड जोड़ें:
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पैरामीटर, कॉम्पोनेंट को इस कंटेनर के लिए किसी भी बाहरी लाइब्रेरी की डिपेंडेंसी के बारे में बताता है. इस मामले में, हम emoji नाम की लाइब्रेरी का इस्तेमाल कर रहे हैं.- यह कॉम्पोनेंट,
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कॉम्पोनेंट से मिलने वालाemoji_textनाम का आउटपुट. अगर हमारी पाइपलाइन को ऐसा टेक्स्ट मिलता है जो किसी इमोजी से मेल नहीं खाता, तो वह इस टेक्स्ट का इस्तेमाल करके एक वाक्य बनाएगी.
@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 Machine Learning के Dry beans dataset का इस्तेमाल करेंगे. यह डेटासेट, KOKLU, M. और OZKAN, I.A. से लिया गया है. (2020), "Multiclass Classification of Dry Beans Using Computer Vision and Machine Learning Techniques."In Computers and Electronics in Agriculture, 174, 105507. DOI.
यह टेबल वाला डेटासेट है. हमारी पाइपलाइन में, हम इस डेटासेट का इस्तेमाल AutoML मॉडल को ट्रेन करने, उसका आकलन करने, और उसे डिप्लॉय करने के लिए करेंगे. यह मॉडल, बीन्स की विशेषताओं के आधार पर उन्हें सात टाइप में से किसी एक में क्लासिफ़ाई करता है.
यह पाइपलाइन ये काम करेगी:
- में डेटासेट बनाना
- AutoML की मदद से, टेबल के डेटा के आधार पर क्लासिफ़िकेशन करने वाले मॉडल को ट्रेन करना
- इस मॉडल के लिए, परफ़ॉर्मेंस का आकलन करने वाली मेट्रिक पाना
- आकलन के मेट्रिक के आधार पर, यह तय करें कि Vertex Pipelines में शर्त के हिसाब से लॉजिक का इस्तेमाल करके मॉडल को डिप्लॉय करना है या नहीं
- Vertex Prediction का इस्तेमाल करके, मॉडल को किसी एंडपॉइंट पर डिप्लॉय करना
यहां बताए गए हर चरण को एक कॉम्पोनेंट माना जाएगा. पाइपलाइन के ज़्यादातर चरणों में, Vertex AI की सेवाओं के लिए पहले से बनाए गए कॉम्पोनेंट का इस्तेमाल किया जाएगा. इसके लिए, हम google_cloud_pipeline_components लाइब्रेरी का इस्तेमाल करेंगे. इसे हमने इस कोडलैब में पहले इंपोर्ट किया था. इस सेक्शन में, हम सबसे पहले एक कस्टम कॉम्पोनेंट तय करेंगे. इसके बाद, हम पहले से बने कॉम्पोनेंट का इस्तेमाल करके, पाइपलाइन के बाकी चरणों को तय करेंगे. पहले से बनाए गए कॉम्पोनेंट की मदद से, मॉडल ट्रेनिंग और डिप्लॉयमेंट जैसी Vertex AI की सेवाओं को आसानी से ऐक्सेस किया जा सकता है.
पहला चरण: मॉडल के आकलन के लिए कस्टम कॉम्पोनेंट
हम जिस कस्टम कॉम्पोनेंट को तय करेंगे उसका इस्तेमाल, मॉडल की ट्रेनिंग पूरी होने के बाद हमारी पाइपलाइन के आखिर में किया जाएगा. यह कॉम्पोनेंट कुछ काम करेगा:
- ट्रेन किए गए AutoML क्लासिफ़िकेशन मॉडल से, आकलन की मेट्रिक पाना
- मेट्रिक को पार्स करता है और उन्हें Vertex Pipelines के यूज़र इंटरफ़ेस (यूआई) में रेंडर करता है
- मेट्रिक की तुलना थ्रेशोल्ड से करें, ताकि यह तय किया जा सके कि मॉडल को डिप्लॉय किया जाना चाहिए या नहीं
कॉम्पोनेंट को तय करने से पहले, आइए इसके इनपुट और आउटपुट पैरामीटर के बारे में जानते हैं. इस पाइपलाइन में इनपुट के तौर पर, हमारे Cloud प्रोजेक्ट का कुछ मेटाडेटा, ट्रेनिंग के बाद तैयार मॉडल (हम इस कॉम्पोनेंट के बारे में बाद में बताएंगे), मॉडल के आकलन की मेट्रिक, और thresholds_dict_str लिया जाता है. thresholds_dict_str को हम पाइपलाइन चलाते समय तय करेंगे. इस क्लासिफ़िकेशन मॉडल के मामले में, यह ROC कर्व के नीचे का वह एरिया होगा जिसके लिए हमें मॉडल को डिप्लॉय करना चाहिए. उदाहरण के लिए, अगर हम 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"]के ज़रिए पिछले कॉम्पोनेंट का आउटपुट दे रहे हैंEndpointCreateOpVertex AI में एक एंडपॉइंट बनाता है. इस चरण में बनाया गया एंडपॉइंट, अगले कॉम्पोनेंट को इनपुट के तौर पर पास किया जाएगाModelDeployOpदिए गए मॉडल को Vertex AI में किसी एंडपॉइंट पर डिप्लॉय करता है. इस मामले में, हम पिछले चरण में बनाए गए एंडपॉइंट का इस्तेमाल कर रहे हैं. कॉन्फ़िगरेशन के अन्य विकल्प भी उपलब्ध हैं. हालांकि, यहां हम एंडपॉइंट मशीन का टाइप और मॉडल दे रहे हैं जिसे हमें डिप्लॉय करना है. हम मॉडल को पास कर रहे हैं. इसके लिए, हम अपनी पाइपलाइन में ट्रेनिंग के चरण के आउटपुट को ऐक्सेस कर रहे हैं
- इस पाइपलाइन में सशर्त लॉजिक का भी इस्तेमाल किया जाता है. यह Vertex Pipelines की एक सुविधा है. इसकी मदद से, कोई शर्त तय की जा सकती है. साथ ही, उस शर्त के नतीजे के आधार पर अलग-अलग ब्रांच तय की जा सकती हैं. याद रखें कि पाइपलाइन तय करते समय, हमने
thresholds_dict_strपैरामीटर पास किया था. यह सटीकता का थ्रेशोल्ड है. इसका इस्तेमाल यह तय करने के लिए किया जाता है कि मॉडल को किसी एंडपॉइंट पर डिप्लॉय करना है या नहीं. इसे लागू करने के लिए, हम KFP SDK कीConditionक्लास का इस्तेमाल करते हैं. हमने इस कोडलैब में पहले ही कस्टम ईवैल कॉम्पोनेंट को तय कर लिया था. यहां पास की गई शर्त, उसी का आउटपुट है. अगर यह शर्त पूरी होती है, तो पाइपलाइन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 की ट्रेनिंग के चरण में लगता है. पूरी पाइपलाइन कुछ ऐसी दिखेगी:
सबसे ऊपर मौजूद "आर्टफ़ैक्ट बड़ा करें" बटन को टॉगल करने पर, आपको अपनी पाइपलाइन से बनाए गए अलग-अलग आर्टफ़ैक्ट की जानकारी दिखेगी. उदाहरण के लिए, dataset आर्टफ़ैक्ट पर क्लिक करने से, आपको बनाए गए Vertex AI डेटासेट के बारे में जानकारी दिखेगी. उस डेटासेट के पेज पर जाने के लिए, यहां दिए गए लिंक पर क्लिक करें:
इसी तरह, कस्टम आकलन कॉम्पोनेंट से मिले मेट्रिक विज़ुअलाइज़ेशन देखने के लिए, metricsc नाम के आर्टफ़ैक्ट पर क्लिक करें. आपको अपने डैशबोर्ड की दाईं ओर, इस मॉडल के लिए कन्फ़्यूज़न मैट्रिक्स दिखेगा:
इस पाइपलाइन रन से बनाए गए मॉडल और एंडपॉइंट को देखने के लिए, मॉडल सेक्शन पर जाएं. इसके बाद, automl-beans नाम वाले मॉडल पर क्लिक करें. आपको वहां इस मॉडल को किसी एंडपॉइंट पर डिप्लॉय किया गया दिखेगा:
इस पेज को ऐक्सेस करने के लिए, पाइपलाइन ग्राफ़ में मौजूद एंडपॉइंट आर्टफ़ैक्ट पर क्लिक करें.
कंसोल में पाइपलाइन ग्राफ़ देखने के अलावा, डेटा सोर्स और डेटा ट्रांसफ़ॉर्मेशन का इतिहास ट्रैक करने के लिए, Vertex Pipelines का भी इस्तेमाल किया जा सकता है. वंशानुक्रम ट्रैकिंग का मतलब है, आपकी पाइपलाइन में बनाए गए आर्टफ़ैक्ट को ट्रैक करना. इससे हमें यह समझने में मदद मिलती है कि आर्टफ़ैक्ट कहां बनाए गए थे और एमएल वर्कफ़्लो में उनका इस्तेमाल कैसे किया जा रहा है. उदाहरण के लिए, इस पाइपलाइन में बनाए गए डेटासेट के लिए लीनेज ट्रैकिंग देखने के लिए, डेटासेट आर्टफ़ैक्ट पर क्लिक करें. इसके बाद, लीनेज देखें पर क्लिक करें:
इससे हमें यह पता चलता है कि इस आर्टफ़ैक्ट का इस्तेमाल कहां-कहां किया जा रहा है:
चौथा चरण: अलग-अलग पाइपलाइन रन के लिए मेट्रिक की तुलना करना
अगर इस पाइपलाइन को कई बार चलाया जाता है, तो आपको अलग-अलग रन के लिए मेट्रिक की तुलना करनी पड़ सकती है. रन मेटाडेटा को ऐक्सेस करने के लिए, 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 पर अपनी पाइपलाइन चलाएं और एसडीके की मदद से पाइपलाइन रन शुरू करें
- कंसोल में, Vertex Pipelines का ग्राफ़ देखना और उसका विश्लेषण करना
- पहले से बनाए गए पाइपलाइन कॉम्पोनेंट का इस्तेमाल करके, अपनी पाइपलाइन में Vertex AI की सेवाएं जोड़ना
- बार-बार होने वाले पाइपलाइन जॉब शेड्यूल करना
Vertex के अलग-अलग हिस्सों के बारे में ज़्यादा जानने के लिए, दस्तावेज़ देखें.
7. साफ़-सफ़ाई सेवा
इसलिए, हमारा सुझाव है कि आप इस लैब में बनाए गए संसाधनों को मिटा दें, ताकि आपसे शुल्क न लिया जाए.
पहला चरण: Notebooks इंस्टेंस को रोकना या मिटाना
अगर आपको इस लैब में बनाई गई नोटबुक का इस्तेमाल जारी रखना है, तो हमारा सुझाव है कि इस्तेमाल न करने पर इसे बंद कर दें. Cloud Console में Notebooks के यूज़र इंटरफ़ेस (यूआई) में जाकर, नोटबुक चुनें. इसके बाद, बंद करें को चुनें. अगर आपको इंस्टेंस को पूरी तरह से मिटाना है, तो मिटाएं को चुनें:
दूसरा चरण: एंडपॉइंट मिटाना
डिप्लॉय किए गए एंडपॉइंट को मिटाने के लिए, Vertex AI कंसोल के एंडपॉइंट सेक्शन पर जाएं और मिटाएं आइकॉन पर क्लिक करें:
इसके बाद, नीचे दिए गए प्रॉम्प्ट में अनडिप्लॉय करें पर क्लिक करें:
आखिर में, अपने कंसोल के मॉडल सेक्शन पर जाएं. इसके बाद, उस मॉडल को ढूंढें और दाईं ओर मौजूद तीन बिंदु वाले मेन्यू में जाकर, मॉडल मिटाएं पर क्लिक करें:
तीसरा चरण: Cloud Storage बकेट मिटाना
स्टोरेज बकेट को मिटाने के लिए, Cloud Console में नेविगेशन मेन्यू का इस्तेमाल करके, स्टोरेज पर जाएं. इसके बाद, अपनी बकेट चुनें और मिटाएं पर क्लिक करें:
