1. खास जानकारी
इस लैब में, आपको Vertex Pipelines पर Kubeflow Pipelines SDK टूल का इस्तेमाल करके, कस्टम मॉडल ट्रेनिंग जॉब चलाने का तरीका बताया जाएगा.
आपको ये सब सीखने को मिलेगा
आपको, इनके बारे में जानकारी मिलेगी:
- बढ़ाने लायक एमएल पाइपलाइन बनाने के लिए, Kubeflow Pipelines SDK टूल का इस्तेमाल करें
- Vertex AI से मैनेज किए जा रहे डेटासेट का इस्तेमाल करके, एक कस्टम Scikit-learn मॉडल ट्रेनिंग जॉब तैयार करें और उसे कंटेनर में तैयार करें. यह जॉब पाइपलाइन में Vertex AI Training पर चलेगा
- Vertex Pipelines में बैच पूर्वानुमान जॉब चलाएं
- Vertex AI की सेवाओं के साथ इंटरैक्ट करने के लिए, पहले से बने कॉम्पोनेंट इस्तेमाल करें. ये कॉम्पोनेंट,
google_cloud_pipeline_componentsलाइब्रेरी के ज़रिए उपलब्ध कराए जाते हैं
Google Cloud पर इस लैब को चलाने की कुल लागत करीब $5 है.
2. Vertex AI के बारे में जानकारी
यह लैब, Vertex AI का इस्तेमाल करता है. यह Google Cloud पर पूरी तरह से मैनेज किया जाने वाला एमएल प्लैटफ़ॉर्म है. Vertex AI की मदद से, Google Cloud के सभी प्लैटफ़ॉर्म पर, Google के मशीन लर्निंग प्लैटफ़ॉर्म को आसानी से डेवलप किया जा सकता है. मॉडल ट्रेनिंग और डिप्लॉयमेंट सेवाओं के अलावा, Vertex AI में कई MLOps प्रॉडक्ट भी शामिल हैं. इनमें Vertex Pipelines (इस लैब का मुख्य मकसद), मॉडल मॉनिटरिंग, फ़ीचर स्टोर वगैरह शामिल हैं. नीचे दिए गए डायग्राम में, Vertex AI के सभी प्रॉडक्ट ऑफ़र देखे जा सकते हैं.
अगर आपका कोई सुझाव, राय या शिकायत है, तो कृपया सहायता पेज पर जाएं.
एमएल पाइपलाइन आपके लिए मददगार क्यों हैं?
आगे बढ़ने से पहले, आइए यह जानें कि आपको पाइपलाइन का इस्तेमाल क्यों करना चाहिए. मान लें कि आपको एक एमएल वर्कफ़्लो बनाना है. इसमें डेटा प्रोसेस करना, मॉडल को ट्रेनिंग देना, हाइपर पैरामीटर ट्यूनिंग, इवैलुएशन, और मॉडल डिप्लॉयमेंट शामिल हैं. इनमें से हर चरण की डिपेंडेंसी अलग-अलग हो सकती है. अगर पूरे वर्कफ़्लो को मोनोलिथ के तौर पर देखा जाता है, तो यह काम मुश्किल हो सकता है. एमएल प्रोसेस का दायरा बढ़ाने के बाद, आपको अपनी टीम के दूसरे सदस्यों के साथ एमएल वर्कफ़्लो शेयर करने की ज़रूरत पड़ सकती है. इससे वे इसे चला सकेंगे और कोड में योगदान दे सकेंगे. भरोसेमंद और दोबारा बनाई जाने वाली प्रोसेस के बिना, काम करना मुश्किल हो सकता है. पाइपलाइन के साथ, आपकी एमएल प्रोसेस का हर चरण उसका अपना कंटेनर होता है. इसकी मदद से, अलग-अलग चरणों को अलग-अलग तरीके से तैयार किया जा सकता है. साथ ही, हर चरण के इनपुट और आउटपुट को फिर से ट्रैक किया जा सकता है. अपने क्लाउड एनवायरमेंट में अन्य इवेंट के आधार पर, पाइपलाइन चलाने की प्रोसेस को शेड्यूल या ट्रिगर किया जा सकता है. जैसे, नया ट्रेनिंग डेटा उपलब्ध होने पर, पाइपलाइन को चलाना.
tl;dr: पाइपलाइन की मदद से, आप अपने एमएल (मशीन लर्निंग) वर्कफ़्लो को आसान बना सकते हैं और उसे फिर से बेहतर बना सकते हैं.
3. क्लाउड एनवायरमेंट का सेटअप
इस कोडलैब को चलाने के लिए, आपके पास Google Cloud Platform का ऐसा प्रोजेक्ट होना चाहिए जिसमें बिलिंग की सुविधा चालू हो. प्रोजेक्ट बनाने के लिए, यहां दिए गए निर्देशों का पालन करें.
पहला चरण: Cloud Shell को शुरू करना
इस लैब में, आपको एक Cloud Shell सेशन में काम करना है. यह एक कमांड इंटरप्रेटर है, जिसे Google के क्लाउड में चल रही एक वर्चुअल मशीन के ज़रिए होस्ट किया जाता है. अपने कंप्यूटर पर, इस सेक्शन को आसानी से चलाया जा सकता है. हालांकि, Cloud Shell का इस्तेमाल करने से सभी लोगों को एक ही तरह के एनवायरमेंट में फिर से जनरेट किए जा सकने वाले अनुभव का ऐक्सेस मिल जाता है. लैब के बाद, अपने कंप्यूटर पर इस सेक्शन को फिर से पब्लिश करने की कोशिश करें.
Cloud Shell चालू करें
Cloud Shell को चालू करने के लिए, Cloud Console में सबसे ऊपर दाईं ओर, नीचे दिए गए बटन पर क्लिक करें:
अगर आपने Cloud Shell का इस्तेमाल पहले कभी नहीं किया है, तो आपको इसके बारे में जानकारी देने वाली एक इंटरमीडिएट स्क्रीन (पेज के फ़ोल्ड के नीचे) दिखेगी. अगर ऐसा है, तो जारी रखें पर क्लिक करें (यह आपको फिर कभी नहीं दिखेगा). एक बार इस्तेमाल होने वाली स्क्रीन कुछ इस तरह दिखती है:
प्रावधान करने और Cloud Shell से कनेक्ट होने में कुछ ही समय लगेगा.
इस वर्चुअल मशीन में ऐसे सभी डेवलपमेंट टूल मौजूद हैं जिनकी आपको ज़रूरत है. यह पांच जीबी की स्थायी होम डायरेक्ट्री उपलब्ध कराता है और Google Cloud में चलता है. इससे नेटवर्क की परफ़ॉर्मेंस और पुष्टि करने की प्रक्रिया को बेहतर बनाने में मदद मिलती है. अगर सभी नहीं, तो इस कोडलैब में आपका बहुत सारा काम बस किसी ब्राउज़र या आपके Chromebook से किया जा सकता है.
Cloud Shell से कनेक्ट करने के बाद, आपको दिखेगा कि आपकी पुष्टि पहले ही हो चुकी है. साथ ही, यह प्रोजेक्ट पहले से ही आपके प्रोजेक्ट आईडी पर सेट है.
यह पुष्टि करने के लिए Cloud Shell में नीचे दिया गया कमांड चलाएं कि आपकी पुष्टि हो गई है:
gcloud auth list
आपको कमांड आउटपुट में कुछ ऐसा दिखेगा:
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 पर क्लिक करें:
इसके बाद, उपयोगकर्ता की ओर से मैनेज की जाने वाली नोटबुक में, नई नोटबुक पर क्लिक करें:
इसके बाद, बिना जीपीयू के TensorFlow Enterprise 2.3 (एलटीएस के साथ) इंस्टेंस टाइप चुनें:
डिफ़ॉल्ट विकल्पों का इस्तेमाल करें और फिर बनाएं पर क्लिक करें.
पांचवां चरण: अपनी Notebook खोलें
इंस्टेंस बनाने के बाद, JupyterLab खोलें को चुनें:
4. Vertex Pipelines का सेटअप
Vertex Pipelines का इस्तेमाल करने के लिए, हमें कुछ और लाइब्रेरी इंस्टॉल करनी होंगी:
- Kubeflow Pipelines: इस SDK टूल का इस्तेमाल हम अपनी पाइपलाइन बनाने के लिए करेंगे. Vertex Pipelines, Kubeflow Pipelines या TFX दोनों के साथ बनाई गई चलाने वाली पाइपलाइन के साथ काम करता है.
- Google Cloud पाइपलाइन कॉम्पोनेंट: इस लाइब्रेरी में पहले से बने कॉम्पोनेंट मिलते हैं. इनकी मदद से, पाइपलाइन स्टेप में 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"
चरण 3: लाइब्रेरी इंपोर्ट करें
इस कोडलैब के दौरान हम जिन लाइब्रेरी का इस्तेमाल करेंगे उन्हें इंपोर्ट करने के लिए, यहां दिए गए कोड जोड़ें:
from kfp.v2 import compiler, dsl
from kfp.v2.dsl import pipeline
from google.cloud import aiplatform
from google_cloud_pipeline_components import aiplatform as gcc_aip
चौथा चरण: कॉन्सटेंट को परिभाषित करना
अपनी पाइपलाइन बनाने से पहले हमें कुछ कॉन्सटैंट वैरिएबल तय करना होता है. 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. कस्टम मॉडल ट्रेनिंग जॉब कॉन्फ़िगर करना
अपनी पाइपलाइन सेट अप करने से पहले, हमें अपने कस्टम मॉडल ट्रेनिंग जॉब के लिए कोड लिखना होगा. इस मॉडल को ट्रेनिंग देने के लिए, हम UCI मशीन लर्निंग के ड्राई बीन डेटासेट का इस्तेमाल करेंगे. ये डेटासेट KOKLU, M., OZKAN, I.A., (2020), "कंप्यूटर विज़न ऐंड मशीन लर्निंग टेक्निक्स का इस्तेमाल करके ड्राई बीन का मल्टीक्लास क्लासिफ़िकेशन.":** कंप्यूटर ऐंड इलेक्ट्रॉनिक्स इन एग्रीकल्चर, 174, 105507. DOI.
पाइपलाइन का हमारा पहला चरण, BigQuery टेबल का इस्तेमाल करके Vertex AI में मैनेज किया जा रहा डेटासेट बनाएगा, जिसमें इस बीन डेटा का वर्शन शामिल होगा. इस डेटासेट को इनपुट के तौर पर हमारे ट्रेनिंग जॉब में पास किया जाएगा. हमारे ट्रेनिंग कोड में, मैनेज किए जा रहे इस डेटासेट को ऐक्सेस करने के लिए, हमारे पास एनवायरमेंट वैरिएबल का ऐक्सेस होगा.
यहां बताया गया है कि हम कस्टम ट्रेनिंग जॉब को कैसे सेट अप करेंगे:
- हमारे डेटा में बीन के टाइप की कैटगरी तय करने के लिए, Scikit-learn
DecisionTreeClassifierमॉडल लिखें - ट्रेनिंग कोड को Docker कंटेनर में पैकेज करें और उसे कंटेनर Registry में भेजें
इसके बाद, हम सीधे अपनी पाइपलाइन से Vertex AI की ट्रेनिंग का काम शुरू कर पाएंगे. आइए, शुरू करें!
पहला चरण: Docker कंटेनर में हमारा ट्रेनिंग कोड तय करना
अपने Notebooks इंस्टेंस से, लॉन्चर खोलें और Terminal चुनें:
इसके बाद, एक डायरेक्ट्री सेट अप करने के लिए यह तरीका अपनाएं, जहां आप कंटेनर वाला कोड जोड़ेंगे:
mkdir traincontainer
cd traincontainer
touch Dockerfile
mkdir trainer
touch trainer/train.py
उन निर्देशों को लागू करने के बाद, आपको बाईं ओर बनाई गई traincontainer/ नाम की डायरेक्ट्री दिखेगी. इसे देखने के लिए, आपको रीफ़्रेश आइकॉन पर क्लिक करना पड़ सकता है. आपको अपनी traincontainer/ डायरेक्ट्री में यह जानकारी दिखेगी:
+ Dockerfile
+ trainer/
+ train.py
अपने कोड को कंटेनर बनाने की प्रक्रिया का हमारा पहला कदम है Dockerfile. हम Dockerfile में, इमेज को चलाने के लिए ज़रूरी सभी निर्देशों को शामिल करते हैं. यह उन सभी लाइब्रेरी को इंस्टॉल करेगा जिनका हम इस्तेमाल कर रहे हैं. साथ ही, यह हमारे ट्रेनिंग कोड के लिए एंट्री पॉइंट सेट अप करेगा. आपने अभी जो Dockerfile बनाया है, उसे खोलें और इन्हें जोड़ें:
FROM gcr.io/deeplearning-platform-release/sklearn-cpu.0-23
WORKDIR /
# Copies the trainer code to the docker image.
COPY trainer /trainer
RUN pip install sklearn google-cloud-bigquery joblib pandas google-cloud-storage
# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "-m", "trainer.train"]
अपने notebook के इंस्टेंस में फ़ाइलों में बदलाव करते समय उन्हें सेव करने के लिए, ctrl+s का इस्तेमाल करें.
इसके बाद, train.py फ़ाइल खोलें. यहां हम अपना ट्रेनिंग कोड जोड़ेंगे. इन्हें train.py में कॉपी करें. यह हमारे मैनेज किए जा रहे डेटासेट से डेटा हासिल करता है, उसे Pandas DataFrame में डालता है, Scikit-learn मॉडल को ट्रेनिंग देता है, और ट्रेन किए गए मॉडल को Cloud Storage में अपलोड करता है:
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import roc_curve
from sklearn.model_selection import train_test_split
from google.cloud import bigquery
from google.cloud import storage
from joblib import dump
import os
import pandas as pd
bqclient = bigquery.Client()
storage_client = storage.Client()
def download_table(bq_table_uri: str):
prefix = "bq://"
if bq_table_uri.startswith(prefix):
bq_table_uri = bq_table_uri[len(prefix):]
table = bigquery.TableReference.from_string(bq_table_uri)
rows = bqclient.list_rows(
table,
)
return rows.to_dataframe(create_bqstorage_client=False)
# These environment variables are from Vertex AI managed datasets
training_data_uri = os.environ["AIP_TRAINING_DATA_URI"]
test_data_uri = os.environ["AIP_TEST_DATA_URI"]
# Download data into Pandas DataFrames, split into train / test
df = download_table(training_data_uri)
test_df = download_table(test_data_uri)
labels = df.pop("Class").tolist()
data = df.values.tolist()
test_labels = test_df.pop("Class").tolist()
test_data = test_df.values.tolist()
# Define and train the Scikit model
skmodel = DecisionTreeClassifier()
skmodel.fit(data, labels)
score = skmodel.score(test_data, test_labels)
print('accuracy is:',score)
# Save the model to a local file
dump(skmodel, "model.joblib")
# Upload the saved model file to GCS
bucket = storage_client.get_bucket("YOUR_GCS_BUCKET")
model_directory = os.environ["AIP_MODEL_DIR"]
storage_path = os.path.join(model_directory, "model.joblib")
blob = storage.blob.Blob.from_string(storage_path, client=storage_client)
blob.upload_from_filename("model.joblib")
इसके बाद, अपनी नोटबुक पर वापस जाएं और ऊपर दी गई स्क्रिप्ट से YOUR_GCS_BUCKET को अपने Cloud Storage बकेट के नाम से बदलने के लिए, यह तरीका अपनाएं:
BUCKET = BUCKET_NAME[5:] # Trim the 'gs://' before adding to train script
!sed -i -r 's@YOUR_GCS_BUCKET@'"$BUCKET"'@' traincontainer/trainer/train.py
अगर आप चाहें, तो इसे मैन्युअल तरीके से भी किया जा सकता है. अगर ऐसा किया जाता है, तो स्क्रिप्ट अपडेट करते समय अपने बकेट के नाम में gs:// को शामिल न करें.
अब हमारा ट्रेनिंग कोड Docker कंटेनर में है और हम क्लाउड में ट्रेनिंग चलाने के लिए तैयार हैं.
दूसरा चरण: कंटेनर को कंटेनर रजिस्ट्री में भेजना
हमारा ट्रेनिंग कोड पूरा हो जाने के बाद, हम इसे Google कंटेनर रजिस्ट्री में भेजने के लिए तैयार हैं. बाद में, जब हम अपनी पाइपलाइन के ट्रेनिंग कॉम्पोनेंट को कॉन्फ़िगर करेंगे, तो हम Vertex Pipelines को इस कंटेनर पर पॉइंट करेंगे.
अपने टर्मिनल पर वापस जाएं और अपनी traincontainer/ डायरेक्ट्री के रूट से, कंटेनर रजिस्ट्री में अपनी कंटेनर इमेज के लिए, यूआरआई वाला वैरिएबल तय करें.
PROJECT_ID=$(gcloud config get-value project)
IMAGE_URI="gcr.io/$PROJECT_ID/scikit:v1"
इसके बाद, नीचे दिए गए तरीके का इस्तेमाल करके अपना कंटेनर बनाएं:
docker build ./ -t $IMAGE_URI
आखिर में, कंटेनर को कंटेनर रजिस्ट्री में भेजें:
docker push $IMAGE_URI
अपने Cloud Console के कंटेनर रजिस्ट्री सेक्शन पर जाकर देखें कि आपका कंटेनर वहां मौजूद है या नहीं. यह कुछ-कुछ ऐसा दिखाई देगा:
6. बैच अनुमान जॉब कॉन्फ़िगर करना
हमारी पाइपलाइन के आखिरी चरण में बैच अनुमान का काम किया जाएगा. यह सुविधा काम करे, इसके लिए हमें Cloud Storage में एक CSV फ़ाइल देनी होगी. इसमें वे उदाहरण शामिल होंगे जिन पर आपको सुझाव दिखाने हैं. हम इस CSV फ़ाइल को अपनी नोटबुक में बनाएंगे और gsutil कमांड-लाइन टूल का इस्तेमाल करके, इसे Cloud Storage में कॉपी करेंगे.
बैच के अनुमान के उदाहरण, Cloud Storage में कॉपी किए जा रहे हैं
नीचे दी गई फ़ाइल में, हमारे बीन्स डेटासेट की हर क्लास के तीन उदाहरण दिए गए हैं. नीचे दिए गए उदाहरण में Class कॉलम शामिल नहीं है, क्योंकि हमारा मॉडल इसी का अनुमान लगाएगा. इस CSV फ़ाइल को अपने नोटबुक में स्थानीय तौर पर बनाने के लिए, नीचे दिया गया तरीका अपनाएं:
%%writefile batch_examples.csv
Area,Perimeter,MajorAxisLength,MinorAxisLength,AspectRation,Eccentricity,ConvexArea,EquivDiameter,Extent,Solidity,roundness,Compactness,ShapeFactor1,ShapeFactor2,ShapeFactor3,ShapeFactor4
23288,558.113,207.567738,143.085693,1.450653336,0.7244336162,23545,172.1952453,0.8045881703,0.9890847314,0.9395021523,0.8295857874,0.008913077034,0.002604069884,0.6882125787,0.9983578734
23689,575.638,205.9678003,146.7475015,1.403552348,0.7016945718,24018,173.6714472,0.7652721693,0.9863019402,0.8983750474,0.8431970773,0.00869465998,0.002711119968,0.7109813112,0.9978994889
23727,559.503,189.7993849,159.3717704,1.190922235,0.5430731512,24021,173.8106863,0.8037601626,0.9877607094,0.952462433,0.9157600082,0.007999299741,0.003470231343,0.8386163926,0.9987269085
31158,641.105,212.0669751,187.1929601,1.132879009,0.4699241567,31474,199.1773023,0.7813134733,0.989959967,0.9526231013,0.9392188582,0.0068061806,0.003267009878,0.8821320637,0.9993488983
32514,649.012,221.4454899,187.1344232,1.183349841,0.5346736437,32843,203.4652564,0.7849831,0.9899826447,0.9700068737,0.9188051492,0.00681077351,0.002994124691,0.8442029022,0.9989873701
33078,659.456,235.5600775,178.9312328,1.316483846,0.6503915309,33333,205.2223615,0.7877214708,0.9923499235,0.9558229607,0.8712102818,0.007121351881,0.002530662194,0.7590073551,0.9992209221
33680,683.09,256.203255,167.9334938,1.525623324,0.7552213942,34019,207.081404,0.80680321,0.9900349805,0.9070392732,0.8082699962,0.007606985006,0.002002710402,0.6533003868,0.9966903078
33954,716.75,277.3684803,156.3563259,1.773951126,0.825970469,34420,207.9220419,0.7994819873,0.9864613597,0.8305492781,0.7496238998,0.008168948587,0.001591181142,0.5619359911,0.996846984
36322,719.437,272.0582306,170.8914975,1.591993952,0.7780978465,36717,215.0502424,0.7718560075,0.9892420405,0.8818487005,0.7904566678,0.007490177594,0.001803782407,0.6248217437,0.9947124371
36675,742.917,285.8908964,166.8819538,1.713132487,0.8119506999,37613,216.0927123,0.7788277766,0.9750618137,0.8350248381,0.7558572692,0.0077952528,0.001569528272,0.5713202115,0.9787472145
37454,772.679,297.6274753,162.1493177,1.835514817,0.8385619338,38113,218.3756257,0.8016695205,0.9827093118,0.7883332637,0.7337213257,0.007946480356,0.001420623993,0.5383469838,0.9881438654
37789,766.378,313.5680678,154.3409867,2.031657789,0.8704771226,38251,219.3500608,0.7805870567,0.9879218844,0.8085170916,0.6995293312,0.008297866252,0.001225659709,0.4893412853,0.9941740339
47883,873.536,327.9986493,186.5201272,1.758516115,0.822571799,48753,246.9140116,0.7584464543,0.9821549443,0.7885506623,0.7527897207,0.006850002074,0.00135695419,0.5666923636,0.9965376533
49777,861.277,300.7570338,211.6168613,1.42123379,0.7105823885,50590,251.7499649,0.8019106536,0.9839296304,0.843243269,0.8370542883,0.00604208839,0.001829706116,0.7006598815,0.9958014989
49882,891.505,357.1890036,179.8346914,1.986207449,0.8640114945,51042,252.0153467,0.7260210171,0.9772736178,0.7886896753,0.7055518063,0.007160679276,0.001094585314,0.4978033513,0.9887407248
53249,919.923,325.3866286,208.9174205,1.557489212,0.7666552108,54195,260.3818974,0.6966846347,0.9825445152,0.7907120655,0.8002231025,0.00611066177,0.001545654241,0.6403570138,0.9973491406
61129,964.969,369.3481688,210.9473449,1.750902193,0.8208567513,61796,278.9836198,0.7501135067,0.9892064211,0.8249553283,0.7553404711,0.006042110436,0.001213219664,0.5705392272,0.9989583843
61918,960.372,353.1381442,224.0962377,1.575832543,0.7728529173,62627,280.7782864,0.7539207091,0.9886790043,0.8436218213,0.7950947556,0.005703319619,0.00140599258,0.6321756704,0.9962029945
141953,1402.05,524.2311633,346.3974998,1.513380332,0.7505863011,143704,425.1354762,0.7147107987,0.9878152313,0.9074598849,0.8109694843,0.003692991084,0.0009853172185,0.6576715044,0.9953071199
145285,1440.991,524.9567463,353.0769977,1.486805285,0.7400216694,146709,430.0960442,0.7860466375,0.9902937107,0.8792413513,0.8192980608,0.003613289371,0.001004269363,0.6712493125,0.9980170255
146153,1476.383,526.1933264,356.528288,1.475881001,0.7354662103,149267,431.3789276,0.7319360978,0.9791380546,0.8425962592,0.8198107159,0.003600290972,0.001003163512,0.6720896099,0.991924286
इसके बाद, फ़ाइल को अपने Cloud Storage बकेट में कॉपी करें:
!gsutil cp batch_examples.csv $BUCKET_NAME
अपनी पाइपलाइन तय करते समय, हम अगले चरण में इस फ़ाइल का रेफ़रंस देंगे.
7. पहले से बने कॉम्पोनेंट की मदद से पाइपलाइन बनाना
अब हमारा ट्रेनिंग कोड क्लाउड में उपलब्ध है, इसलिए हम इसे अपनी पाइपलाइन से कॉल करने के लिए तैयार हैं. हम जो पाइपलाइन तय करेंगे वह google_cloud_pipeline_components लाइब्रेरी में मौजूद, पहले से बने तीन कॉम्पोनेंट का इस्तेमाल करेगी, जिन्हें हमने पहले इंस्टॉल किया था. ये पहले से तय कॉम्पोनेंट, हमारे पाइपलाइन को सेट अप करने के लिए ज़रूरी कोड को आसान बनाते हैं. साथ ही, इनकी मदद से हम Vertex AI की सेवाओं का इस्तेमाल कर पाएंगे, जैसे कि मॉडल ट्रेनिंग और बैच का अनुमान लगाने की सुविधा.
यहां बताया गया है कि हमारी तीन-चरणों वाली पाइपलाइन क्या करेगी:
- Vertex AI में मैनेज किया जा रहा डेटासेट बनाएं
- हमने जो कस्टम कंटेनर सेट अप किया है उसका इस्तेमाल करके, Vertx AI पर ट्रेनिंग जॉब चलाएं
- हमारे ट्रेनिंग पा चुके Scikit-लर्निंग मॉडल के आधार पर, बैच के अनुमान वाला जॉब चलाएं
पहला चरण: हमारी पाइपलाइन तय करना
हम पहले से बने कॉम्पोनेंट इस्तेमाल कर रहे हैं, इसलिए हम पाइपलाइन की परिभाषा में अपनी पूरी पाइपलाइन सेट अप कर सकते हैं. नोटबुक के सेल में ये चीज़ें जोड़ें:
@pipeline(name="automl-beans-custom",
pipeline_root=PIPELINE_ROOT)
def pipeline(
bq_source: str = "bq://sara-vertex-demos.beans_demo.large_dataset",
bucket: str = BUCKET_NAME,
project: str = PROJECT_ID,
gcp_region: str = REGION,
bq_dest: str = "",
container_uri: str = "",
batch_destination: str = ""
):
dataset_create_op = gcc_aip.TabularDatasetCreateOp(
display_name="tabular-beans-dataset",
bq_source=bq_source,
project=project,
location=gcp_region
)
training_op = gcc_aip.CustomContainerTrainingJobRunOp(
display_name="pipeline-beans-custom-train",
container_uri=container_uri,
project=project,
location=gcp_region,
dataset=dataset_create_op.outputs["dataset"],
staging_bucket=bucket,
training_fraction_split=0.8,
validation_fraction_split=0.1,
test_fraction_split=0.1,
bigquery_destination=bq_dest,
model_serving_container_image_uri="us-docker.pkg.dev/vertex-ai/prediction/sklearn-cpu.0-24:latest",
model_display_name="scikit-beans-model-pipeline",
machine_type="n1-standard-4",
)
batch_predict_op = gcc_aip.ModelBatchPredictOp(
project=project,
location=gcp_region,
job_display_name="beans-batch-predict",
model=training_op.outputs["model"],
gcs_source_uris=["{0}/batch_examples.csv".format(BUCKET_NAME)],
instances_format="csv",
gcs_destination_output_uri_prefix=batch_destination,
machine_type="n1-standard-4"
)
दूसरा चरण: पाइपलाइन को कंपाइल करना और चलाना
अपनी पाइपलाइन निर्धारित होने के बाद, आप उसे कंपाइल करने के लिए तैयार हैं. यहां दी गई एपीआई एक JSON फ़ाइल जनरेट करेगी, जिसका इस्तेमाल आप पाइपलाइन चलाने के लिए करेंगे:
compiler.Compiler().compile(
pipeline_func=pipeline, package_path="custom_train_pipeline.json"
)
इसके बाद, TIMESTAMP वैरिएबल बनाएं. हम इसका इस्तेमाल अपने जॉब आईडी में करेंगे:
from datetime import datetime
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
इसके बाद, कुछ प्रोजेक्ट के खास पैरामीटर पास करके, पाइपलाइन जॉब तय करें:
pipeline_job = aiplatform.PipelineJob(
display_name="custom-train-pipeline",
template_path="custom_train_pipeline.json",
job_id="custom-train-pipeline-{0}".format(TIMESTAMP),
parameter_values={
"project": PROJECT_ID,
"bucket": BUCKET_NAME,
"bq_dest": "bq://{0}".format(PROJECT_ID),
"container_uri": "gcr.io/{0}/scikit:v1".format(PROJECT_ID),
"batch_destination": "{0}/batchpredresults".format(BUCKET_NAME)
},
enable_caching=True,
)
आखिर में, नई पाइपलाइन बनाने के लिए जॉब चलाएं:
pipeline_job.submit()
इस सेल को चलाने के बाद, आपको अपने कंसोल में चलने वाले पाइपलाइन को देखने के लिए, लिंक के साथ लॉग दिखेंगे:
उस लिंक पर जाएं. Pipelines डैशबोर्ड खोलकर भी इसे ऐक्सेस किया जा सकता है. पूरा होने पर आपकी पाइपलाइन कुछ ऐसी दिखनी चाहिए:
इस पाइपलाइन को चलाने में 5 से 10 मिनट लगेंगे, लेकिन इसके पूरा होने से पहले आप अगले चरण पर जा सकते हैं. इसके बाद, आपको इस बारे में ज़्यादा जानकारी मिलेगी कि इन पाइपलाइन के हर चरण में क्या हो रहा है.
8. अपनी पाइपलाइन के एक्ज़ीक्यूशन के बारे में समझना
आइए, हमारे तीन पाइपलाइन चरणों में से प्रत्येक चरण के बारे में गहराई से जानें.
पाइपलाइन का पहला चरण: मैनेज किया जा रहा डेटासेट बनाना
हमारी पाइपलाइन का पहला चरण, Vertex AI में मैनेज किया जा रहा डेटासेट बनाता है. अपने कंसोल के पाइपलाइन सेक्शन में, इस डेटासेट के लिंक पर क्लिक करने पर:
आपको अपना डेटासेट Vertex AI में दिखेगा. इसमें BigQuery के डेटा सोर्स का लिंक और आपके डेटासेट के अलग-अलग कॉलम की जानकारी शामिल होती है. मैनेज किए जा रहे डेटासेट को Vertex AI में अपलोड करने के बाद, इसका इस्तेमाल AutoML या कस्टम मॉडल को ट्रेनिंग देने के लिए किया जा सकता है.
मैनेज किए जा रहे डेटासेट का इस्तेमाल करने वाले कस्टम मॉडल जॉब के लिए, Vertex AI आपकी ट्रेनिंग जॉब के लिए खास एनवायरमेंट वैरिएबल पास करता है. साथ ही, आपके डेटा को ट्रेन और टेस्ट सेट में बांटने का काम भी करता है. हम अपने अगले चरण में इसका इस्तेमाल करेंगे.
पाइपलाइन का दूसरा चरण: Vertex AI की ट्रेनिंग में मॉडल को ट्रेनिंग देना
जब तक आपका कस्टम ट्रेनिंग जॉब चल रहा है, तब तक सीधे Vertex Pipelines कंसोल में लॉग देखने के लिए, क्लिक किया जा सकता है:
Vertex AI ट्रेनिंग डैशबोर्ड में, आपको अपनी पसंद के मुताबिक बनाई गई ट्रेनिंग के बारे में जानकारी मिल सकती है. ट्रेनिंग पूरी होने के बाद, Vertex AI में मॉडल रिसॉर्स बन जाएगा. इसके बाद, हम इस मॉडल को ऑनलाइन अनुमानों के लिए एंडपॉइंट पर डिप्लॉय कर सकते हैं या बैच के लिए अनुमान लगाने का जॉब बना सकते हैं. यह काम हम अपने अगले चरण में करेंगे.
पाइपलाइन चरण 3: अपने मॉडल पर बैच अनुमान वाला काम चलाना
आखिर में, हमारी पाइपलाइन में उन उदाहरणों के सुझाव मिलेंगे जिन्हें हमने CSV फ़ाइल से पास किया है. बैच के लिए अनुमान लगाने का काम पूरा हो जाने पर Vertex AI, Cloud Storage में बताई गई जगह के लिए CSV फ़ाइल तैयार करेगा. पाइपलाइन के इस चरण के चलने के बाद, अपने Vertex AI कंसोल के बैच अनुमान सेक्शन पर जाकर, बनाया गया काम देखा जा सकता है.
अपने बैच के अनुमानों का Cloud Storage यूआरएल देखने के लिए, अपना काम पूरा हो जाने पर उस पर क्लिक करें:
Cloud Storage डायरेक्ट्री पर जाने के लिए, उस लिंक पर क्लिक करें. यहां आपको सुझाव के तौर पर नतीजे मिलेंगे. इसके बाद, prediction.results में से किसी एक फ़ाइल को डाउनलोड करने के लिए क्लिक करें. फ़ाइल में आपको कुछ इस तरह की पंक्तियां दिखेंगी:
{"instance": [33954.0, 716.75, 277.3684803, 156.3563259, 1.773951126, 0.825970469, 34420.0, 207.9220419, 0.7994819873, 0.9864613597, 0.8305492781, 0.7496238998, 0.008168948587, 0.001591181142, 0.5619359911, 0.996846984], "prediction": "HOROZ"}
इसमें किसी खास इंस्टेंस के लिए, सुविधा की वैल्यू के साथ-साथ वह क्लास भी शामिल होती है जिसका अनुमान हमारे मॉडल ने लगाया था. इस उदाहरण के लिए, हमारे मॉडल को लगता है कि यह "HOROZ" था फली.
इसके साथ ही, आपने लैब खत्म कर लिया है!
🎉 बधाई हो! 🎉
आपने Vertex AI को इस्तेमाल करने का तरीका जान लिया है, ताकि:
- Kubeflow Pipelines SDK टूल का इस्तेमाल करके, कस्टम कॉम्पोनेंट की मदद से एंड-टू-एंड पाइपलाइन बनाएं
- Vertex Pipelines पर अपनी पाइपलाइन चलाएं और SDK टूल की मदद से, पाइपलाइन चलाएं
- कंसोल में, Vertex Pipelines ग्राफ़ देखें और उसका विश्लेषण करें
- अपनी पाइपलाइन में Vertex AI की सेवाएं जोड़ने के लिए, पहले से बने पाइपलाइन कॉम्पोनेंट का इस्तेमाल करें
- बार-बार होने वाले पाइपलाइन जॉब शेड्यूल करें
Vertex के अलग-अलग हिस्सों के बारे में ज़्यादा जानने के लिए, दस्तावेज़ देखें.
9. साफ़-सफ़ाई सेवा
आपसे शुल्क न लिया जाए, इसलिए हमारा सुझाव है कि आप इस लैब में बनाए गए संसाधनों को मिटा दें.
पहला चरण: अपने Notebooks इंस्टेंस को रोकना या मिटाना
यदि आप इस लैब में बनाए गए नोटबुक का उपयोग करना जारी रखना चाहते हैं, तो यह अनुशंसा की जाती है कि आप उपयोग में नहीं होने पर इसे बंद कर दें. अपने Cloud Console में Notebook के यूज़र इंटरफ़ेस (यूआई) से, नोटबुक चुनें और फिर बंद करें चुनें. अगर आपको इस इंस्टेंस को पूरी तरह से मिटाना है, तो मिटाएं चुनें:
दूसरा चरण: Cloud Storage बकेट को मिटाना
अपने Cloud Console में नेविगेशन मेन्यू का इस्तेमाल करके, स्टोरेज बकेट मिटाने के लिए स्टोरेज पर जाएं. इसके बाद, अपनी बकेट चुनें और मिटाएं पर क्लिक करें:
