1. खास जानकारी
इस लैब में, आपको Vertex AI पर कस्टम अनुमान रूटीन का इस्तेमाल करने का तरीका पता चलेगा. इससे, डेटा को पहले से तैयार करने और बाद में प्रोसेस करने का कस्टम लॉजिक लिखा जा सकता है. इस सैंपल में Scikit-learn का इस्तेमाल किया गया है. हालांकि, कस्टम अनुमान रूटीन, XGBoost, PyTorch, और TensorFlow जैसे अन्य Python ML फ़्रेमवर्क के साथ काम कर सकते हैं.
आपको ये सब सीखने को मिलेगा
आपको, इनके बारे में जानकारी मिलेगी:
- कस्टम अनुमान के रूटीन की मदद से, अनुमान का कस्टम लॉजिक लिखना
- कस्टम सर्विंग कंटेनर और मॉडल को स्थानीय तौर पर टेस्ट करना
- Vertex AI अनुमान पर कस्टम सर्विंग कंटेनर की जांच करें
Google Cloud पर इस लैब को चलाने की कुल लागत करीब 1 डॉलर है.
2. Vertex AI के बारे में जानकारी
यह लैब, Google Cloud पर उपलब्ध एआई (AI) प्रॉडक्ट के सबसे नए वर्शन का इस्तेमाल करता है. Vertex AI, Google Cloud के सभी मशीन लर्निंग प्लैटफ़ॉर्म को आसानी से डेवलप करने के लिए इंटिग्रेट करता है. पहले, AutoML और कस्टम मॉडल की मदद से ट्रेन किए गए मॉडल अलग-अलग सेवाओं से ऐक्सेस किए जा सकते थे. नई सुविधा में, दोनों को एक ही एपीआई में जोड़ा गया है. साथ ही, इसमें अन्य नए प्रॉडक्ट भी शामिल हैं. मौजूदा प्रोजेक्ट को Vertex AI पर भी माइग्रेट किया जा सकता है.
Vertex AI में कई अलग-अलग प्रॉडक्ट शामिल हैं, ताकि एंड-टू-एंड एमएल वर्कफ़्लो को बेहतर बनाया जा सके. इस लैब में, अनुमान और वर्कबेंच पर फ़ोकस किया जाएगा.
3. इस्तेमाल के उदाहरण की खास जानकारी
इस्तेमाल का उदाहरण
इस लैब में, आपको रैंडम फ़ॉरेस्ट रेग्रेसन मॉडल बनाना होगा. इससे, डायमंड की कीमत का अनुमान लगाया जा सकेगा. यह अनुमान, डायमंड के कट, क्लैरिटी, और साइज़ जैसे एट्रिब्यूट के आधार पर लगाया जाएगा.
आपको डेटा को प्री-प्रोसेस करने के लिए कस्टम लॉजिक लिखना होगा. इससे यह पक्का किया जा सकेगा कि डेटा, मॉडल के लिए सही फ़ॉर्मैट में हो. आपको अनुमान को राउंड करने और उन्हें स्ट्रिंग में बदलने के लिए, पोस्ट-प्रोसेसिंग का कस्टम लॉजिक भी लिखना होगा. यह लॉजिक लिखने के लिए, आपको अनुमान के कस्टम रूटीन का इस्तेमाल करना होगा.
अनुमान के लिए कस्टम रूटीन के बारे में जानकारी
Vertex AI के पहले से बने कंटेनर, मशीन लर्निंग फ़्रेमवर्क के अनुमान लगाने की प्रोसेस को पूरा करके, अनुमान लगाने के अनुरोधों को मैनेज करते हैं. कस्टम अनुमान के रूटीन से पहले, अगर आपको अनुमान लगाने से पहले इनपुट को प्री-प्रोसेस करना है या नतीजा दिखाने से पहले मॉडल के अनुमान को पोस्ट-प्रोसेस करना है, तो आपको कस्टम कंटेनर बनाना होगा.
कस्टम सर्विंग कंटेनर बनाने के लिए, एचटीटीपी सर्वर लिखना ज़रूरी है. यह सर्वर, ट्रेन किए गए मॉडल को रैप करता है, एचटीटीपी अनुरोधों को मॉडल इनपुट में बदलता है, और मॉडल आउटपुट को रिस्पॉन्स में बदलता है.
अनुमान लगाने के कस्टम रूटीन की मदद से, Vertex AI आपको सेवा देने से जुड़े कॉम्पोनेंट उपलब्ध कराता है, ताकि आप अपने मॉडल और डेटा ट्रांसफ़ॉर्मेशन पर फ़ोकस कर सकें.
4. अपना एनवायरमेंट सेट अप करना
इस कोडलैब को चलाने के लिए, आपके पास बिलिंग की सुविधा वाला Google Cloud Platform प्रोजेक्ट होना चाहिए. प्रोजेक्ट बनाने के लिए, यहां दिए गए निर्देशों का पालन करें.
पहला चरण: Compute Engine API चालू करना
Compute Engine पर जाएं और अगर यह पहले से चालू नहीं है, तो चालू करें को चुनें. नोटबुक इंस्टेंस बनाने के लिए, आपको इसकी ज़रूरत होगी.
दूसरा चरण: Artifact Registry API को चालू करना
Artifact Registry पर जाएं और अगर पहले से ऐसा नहीं है, तो चालू करें को चुनें. पसंद के मुताबिक पेश करने वाला कंटेनर बनाने के लिए इसका इस्तेमाल किया जा सकता है.
तीसरा चरण: Vertex AI API को चालू करना
अपने Cloud Console के Vertex AI सेक्शन पर जाएं और Vertex AI API चालू करें पर क्लिक करें.
चौथा चरण: Vertex AI Workbench इंस्टेंस बनाना
अपने Cloud Console के Vertex AI सेक्शन में, वर्कबेंच पर क्लिक करें:
अगर Notebooks API पहले से चालू नहीं है, तो उसे चालू करें.
चालू करने के बाद, इंस्टेंस पर क्लिक करें. इसके बाद, नया बनाएं को चुनें.
डिफ़ॉल्ट विकल्पों को स्वीकार करें और बनाएं पर क्लिक करें.
इंस्टेंस तैयार होने के बाद, इंस्टेंस खोलने के लिए, JUPYTERLAB खोलें पर क्लिक करें.
5. ट्रेनिंग कोड में बदलाव करने की अनुमति दें
पहला चरण: क्लाउड स्टोरेज बकेट बनाना
आपको मॉडल और प्रीप्रोसेसिंग आर्टफ़ैक्ट को Cloud Storage बकेट में सेव करना होगा. अगर आपके प्रोजेक्ट में पहले से ही कोई बकेट है जिसका आपको इस्तेमाल करना है, तो इस चरण को छोड़ा जा सकता है.
लॉन्चर से, नया टर्मिनल सेशन खोलें.
अपने प्रोजेक्ट के लिए एनवायरमेंट वैरिएबल तय करने के लिए, अपने टर्मिनल में यह कमांड चलाएं. साथ ही, your-cloud-project की जगह अपने प्रोजेक्ट का आईडी डालें:
PROJECT_ID='your-cloud-project'
इसके बाद, अपने प्रोजेक्ट में नया बकेट बनाने के लिए, इसे अपने Terminal में चलाएं.
BUCKET="gs://${PROJECT_ID}-cpr-bucket"
gsutil mb -l us-central1 $BUCKET
दूसरा चरण: ट्रेन का मॉडल
टर्मिनल से, cpr-codelab नाम की नई डायरेक्ट्री बनाएं और उसमें cd करें.
mkdir cpr-codelab
cd cpr-codelab
फ़ाइल ब्राउज़र में, नई cpr-codelab डायरेक्ट्री पर जाएं. इसके बाद, लॉन्चर का इस्तेमाल करके task.ipynb नाम की नई Python 3 नोटबुक बनाएं.
आपकी cpr-codelab डायरेक्ट्री अब इस तरह दिखनी चाहिए:
+ cpr-codelab/
+ task.ipynb
नोटबुक में, नीचे दिया गया कोड चिपकाएं.
सबसे पहले, requirements.txt फ़ाइल बनाएं.
%%writefile requirements.txt
fastapi
uvicorn==0.17.6
joblib~=1.0
numpy~=1.20
scikit-learn>=1.2.2
pandas
google-cloud-storage>=1.26.0,<2.0.0dev
google-cloud-aiplatform[prediction]>=1.16.0
आपके डिप्लॉय किए गए मॉडल में, आपके नोटबुक एनवायरमेंट से अलग डिपेंडेंसी पहले से इंस्टॉल होंगी. इस वजह से, आपको requirements.txt में मॉडल की सभी डिपेंडेंसी की सूची बनानी होगी. इसके बाद, नोटबुक में एक जैसी डिपेंडेंसी इंस्टॉल करने के लिए, pip का इस्तेमाल करना होगा. बाद में, Vertex AI पर डिप्लॉय करने से पहले, आपको मॉडल की स्थानीय तौर पर जांच करनी होगी. इससे यह पक्का किया जा सकेगा कि दोनों एनवायरमेंट मैच करते हैं.
Pip, नोटबुक में डिपेंडेंसी इंस्टॉल करता है.
!pip install -U --user -r requirements.txt
ध्यान दें कि pip इंस्टॉल होने के बाद, आपको कर्नेल को रीस्टार्ट करना होगा.
इसके बाद, डायरेक्ट्री बनाएं जहां मॉडल और प्रीप्रोसेसिंग आर्टफ़ैक्ट को स्टोर करना है.
USER_SRC_DIR = "src_dir"
!mkdir $USER_SRC_DIR
!mkdir model_artifacts
# copy the requirements to the source dir
!cp requirements.txt $USER_SRC_DIR/requirements.txt
आपकी cpr-codelab डायरेक्ट्री अब ऐसी दिखेगी:
+ cpr-codelab/
+ model_artifacts/
+ scr_dir/
+ requirements.txt
+ task.ipynb
+ requirements.txt
डायरेक्ट्री का ढांचा सेट अप हो जाने के बाद, अब मॉडल को ट्रेनिंग दें!
सबसे पहले, लाइब्रेरी इंपोर्ट करें.
import seaborn as sns
import numpy as np
import pandas as pd
from sklearn import preprocessing
from sklearn.ensemble import RandomForestRegressor
from sklearn.pipeline import make_pipeline
from sklearn.compose import make_column_transformer
import joblib
import logging
# set logging to see the docker container logs
logging.basicConfig(level=logging.INFO)
इसके बाद, नीचे दिए गए वैरिएबल तय करें. PROJECT_ID की जगह अपना प्रोजेक्ट आईडी और BUCKET_NAME की जगह वह बकेट डालें जो आपने पिछले चरण में बनाई थी.
REGION = "us-central1"
MODEL_ARTIFACT_DIR = "sklearn-model-artifacts"
REPOSITORY = "diamonds"
IMAGE = "sklearn-image"
MODEL_DISPLAY_NAME = "diamonds-cpr"
# Replace with your project
PROJECT_ID = "{PROJECT_ID}"
# Replace with your bucket
BUCKET_NAME = "gs://{BUCKET_NAME}"
seaborn लाइब्रेरी से डेटा लोड करें. इसके बाद, दो डेटाफ़्रेम बनाएं. एक डेटाफ़्रेम में फ़ीचर और दूसरे में लेबल शामिल करें.
data = sns.load_dataset('diamonds', cache=True, data_home=None)
label = 'price'
y_train = data['price']
x_train = data.drop(columns=['price'])
आइए, ट्रेनिंग डेटा पर नज़र डालते हैं. आप देख सकते हैं कि हर पंक्ति एक डायमंड दिखाती है.
x_train.head()
साथ ही, लेबल, जो कि संबंधित कीमतें हैं.
y_train.head()
अब, कैटगरी वाली सुविधाओं को एक बार में कोड में बदलने और संख्या वाली सुविधाओं को स्केल करने के लिए, sklearn कॉलम ट्रांसफ़ॉर्म तय करें
column_transform = make_column_transformer(
(preprocessing.OneHotEncoder(), [1,2,3]),
(preprocessing.StandardScaler(), [0,4,5,6,7,8]))
यादृच्छिक वन मॉडल परिभाषित करना
regr = RandomForestRegressor(max_depth=10, random_state=0)
इसके बाद, sklearn पाइपलाइन बनाएं. इसका मतलब है कि इस पाइपलाइन में डाले गए डेटा को पहले कोड में बदला/स्केल किया जाएगा और फिर मॉडल को भेजा जाएगा.
my_pipeline = make_pipeline(column_transform, regr)
ट्रेनिंग डेटा पर पाइपलाइन फ़िट करना
my_pipeline.fit(x_train, y_train)
आइए, मॉडल को आज़माकर देखें कि यह उम्मीद के मुताबिक काम कर रहा है या नहीं. मॉडल पर predict तरीके को कॉल करें और टेस्ट सैंपल पास करें.
my_pipeline.predict([[0.23, 'Ideal', 'E', 'SI2', 61.5, 55.0, 3.95, 3.98, 2.43]])
अब हम पाइपलाइन को model_artifacts डायरेक्ट्री में सेव कर सकते हैं और उसे Cloud Storage बकेट में कॉपी कर सकते हैं.
joblib.dump(my_pipeline, 'model_artifacts/model.joblib')
!gsutil cp model_artifacts/model.joblib {BUCKET_NAME}/{MODEL_ARTIFACT_DIR}/
तीसरा चरण: प्रीप्रोसेसिंग आर्टफ़ैक्ट सेव करना
इसके बाद, आपको प्रीप्रोसेसिंग आर्टफ़ैक्ट बनाना होगा. मॉडल सर्वर के शुरू होने पर, यह आर्टफ़ैक्ट कस्टम कंटेनर में लोड हो जाएगा. प्रीप्रोसेसिंग आर्टफ़ैक्ट किसी भी फ़ॉर्मैट में हो सकता है, जैसे कि पिकल फ़ाइल. हालांकि, इस मामले में आपको एक डिक्शनरी को JSON फ़ाइल में लिखना होगा.
clarity_dict={"Flawless": "FL",
"Internally Flawless": "IF",
"Very Very Slightly Included": "VVS1",
"Very Slightly Included": "VS2",
"Slightly Included": "S12",
"Included": "I3"}
हमारे ट्रेनिंग डेटा में clarity सुविधा हमेशा छोटा करके लिखी गई थी. जैसे, "बेहतरीन" के बजाय "FL". विज्ञापन दिखाने के समय, हम यह देखना चाहते हैं कि इस सुविधा का डेटा भी छोटा हो. ऐसा इसलिए है, क्योंकि हमारा मॉडल "FL" को एक हीट कोड में बदल सकता है, लेकिन "Flawless" को नहीं. आपको बाद में, डेटा को प्री-प्रोसेस करने के लिए कस्टम लॉजिक लिखना होगा. फ़िलहाल, इस लुक अप टेबल को सिर्फ़ JSON फ़ाइल में सेव करें. इसके बाद, इसे Cloud Storage की बकेट में लिखें.
import json
with open("model_artifacts/preprocessor.json", "w") as f:
json.dump(clarity_dict, f)
!gsutil cp model_artifacts/preprocessor.json {BUCKET_NAME}/{MODEL_ARTIFACT_DIR}/
आपकी लोकल cpr-codelab डायरेक्ट्री अब इस तरह दिखेगी:
+ cpr-codelab/
+ model_artifacts/
+ model.joblib
+ preprocessor.json
+ scr_dir/
+ requirements.txt
+ task.ipynb
+ requirements.txt
6. सीपीआर मॉडल सर्वर का इस्तेमाल करके, कस्टम सर्विंग कंटेनर बनाना
मॉडल को ट्रेनिंग दे दी गई है और प्रीप्रोसेसिंग आर्टफ़ैक्ट सेव हो गया है. अब कस्टम सर्विंग कंटेनर बनाने का समय आ गया है. आम तौर पर, सर्विंग कंटेनर बनाने के लिए, मॉडल सर्वर कोड लिखना ज़रूरी होता है. हालांकि, अनुमान लगाने के कस्टम रूटीन की मदद से, Vertex AI Predictions एक मॉडल सर्वर जनरेट करता है और आपके लिए कस्टम कंटेनर इमेज बनाता है.
कस्टम सर्विंग कंटेनर में ये तीन कोड होते हैं:
- मॉडल सर्वर (यह SDK टूल की मदद से अपने-आप जनरेट होगा और
scr_dir/में सेव होगा)- मॉडल को होस्ट करने वाला एचटीटीपी सर्वर
- रूट, पोर्ट/वगैरह को सेट अप करने की जिम्मेदारी.
- अनुरोध हैंडलर
- यह वेब सर्वर के उन पहलुओं के लिए ज़िम्मेदार है जो अनुरोध को मैनेज करते हैं. जैसे, अनुरोध के मुख्य हिस्से को डी-सीरियलाइज़ करना और रिस्पॉन्स को सीरियलाइज़ करना, रिस्पॉन्स हेडर सेट करना वगैरह.
- इस उदाहरण में, SDK टूल में दिए गए डिफ़ॉल्ट हैंडलर
google.cloud.aiplatform.prediction.handler.PredictionHandlerका इस्तेमाल किया जाएगा.
- प्रेडिकटर
- अनुमान के अनुरोध को प्रोसेस करने के लिए, एमएल लॉजिक की ज़िम्मेदारी.
इनमें से हर कॉम्पोनेंट को, इस्तेमाल के उदाहरण की ज़रूरतों के हिसाब से पसंद के मुताबिक बनाया जा सकता है. इस उदाहरण में, सिर्फ़ अनुमान लगाने वाले मॉडल को लागू किया जाएगा.
अनुमान लगाने वाले मॉडल की ज़िम्मेदारी, अनुमान के अनुरोध को प्रोसेस करने के लिए मशीन लर्निंग लॉजिक को लागू करने की होती है. जैसे, कस्टम प्रीप्रोसेसिंग और पोस्टप्रोसेसिंग. अनुमान का कस्टम लॉजिक लिखने के लिए, आपको Vertex AI Predictor इंटरफ़ेस को सबक्लास करना होगा.
कस्टम अनुमान लगाने के रूटीन की इस रिलीज़ में, XGBoost और Sklearn के ऐसे प्रिडिक्टर शामिल हैं जिन्हें फिर से इस्तेमाल किया जा सकता है. हालांकि, अगर आपको किसी दूसरे फ़्रेमवर्क का इस्तेमाल करना है, तो बेस प्रिडिक्टर की सबक्लास बनाकर अपना प्रिडिक्टर बनाया जा सकता है.
नीचे Sklearn अनुमान का एक उदाहरण दिया गया है. इस कस्टम मॉडल सर्वर को बनाने के लिए, आपको यह पूरा कोड लिखना होगा.
SklearnPredictor को सबक्लास बनाने के लिए, अपनी नोटबुक में नीचे दिया गया कोड चिपकाएं और इसे src_dir/ में मौजूद Python फ़ाइल में लिखें. ध्यान दें कि इस उदाहरण में हम सिर्फ़ load, preprocess, और postprocess तरीकों को पसंद के मुताबिक बना रहे हैं, predict तरीके को नहीं.
%%writefile $USER_SRC_DIR/predictor.py
import joblib
import numpy as np
import json
from google.cloud import storage
from google.cloud.aiplatform.prediction.sklearn.predictor import SklearnPredictor
class CprPredictor(SklearnPredictor):
def __init__(self):
return
def load(self, artifacts_uri: str) -> None:
"""Loads the sklearn pipeline and preprocessing artifact."""
super().load(artifacts_uri)
# open preprocessing artifact
with open("preprocessor.json", "rb") as f:
self._preprocessor = json.load(f)
def preprocess(self, prediction_input: np.ndarray) -> np.ndarray:
"""Performs preprocessing by checking if clarity feature is in abbreviated form."""
inputs = super().preprocess(prediction_input)
for sample in inputs:
if sample[3] not in self._preprocessor.values():
sample[3] = self._preprocessor[sample[3]]
return inputs
def postprocess(self, prediction_results: np.ndarray) -> dict:
"""Performs postprocessing by rounding predictions and converting to str."""
return {"predictions": [f"${value}" for value in np.round(prediction_results)]}
आइए, इनमें से हर तरीके के बारे में ज़्यादा जानें.
loadतरीका, प्री-प्रोसेसिंग आर्टफ़ैक्ट में लोड होता है. इस मामले में, एक डिक्शनरी है, जो हीरे की क्वालिटी की वैल्यू को उनके अब्रिविएशन के साथ मैप करती है.preprocessतरीका उस आर्टफ़ैक्ट का इस्तेमाल करके यह पक्का करता है कि दिखाने के समय, क्लैरिटी की सुविधा छोटे फ़ॉर्मैट में हो. अगर ऐसा नहीं है, तो यह पूरी स्ट्रिंग को उसके छोटे वर्शन में बदल देता है.postprocessतरीका, अनुमानित वैल्यू को $ साइन वाली स्ट्रिंग के तौर पर दिखाता है और वैल्यू को राउंड करता है.
इसके बाद, इमेज बनाने के लिए Vertex AI Python SDK टूल का इस्तेमाल करें. अनुमान लगाने के लिए कस्टम रूटीन का इस्तेमाल करके, Dockerfile जनरेट किया जाएगा और आपके लिए इमेज बनाई जाएगी.
from google.cloud import aiplatform
aiplatform.init(project=PROJECT_ID, location=REGION)
import os
from google.cloud.aiplatform.prediction import LocalModel
from src_dir.predictor import CprPredictor # Should be path of variable $USER_SRC_DIR
local_model = LocalModel.build_cpr_model(
USER_SRC_DIR,
f"{REGION}-docker.pkg.dev/{PROJECT_ID}/{REPOSITORY}/{IMAGE}",
predictor=CprPredictor,
requirements_path=os.path.join(USER_SRC_DIR, "requirements.txt"),
)
अनुमान लगाने के लिए, दो सैंपल वाली टेस्ट फ़ाइल लिखें. एक इंस्टेंस में, छोटा सा नाम है, लेकिन दूसरे इंस्टेंस को पहले बदलना होगा.
import json
sample = {"instances": [
[0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43],
[0.29, 'Premium', 'J', 'Internally Flawless', 52.5, 49.0, 4.00, 2.13, 3.11]]}
with open('instances.json', 'w') as fp:
json.dump(sample, fp)
स्थानीय मॉडल को डिप्लॉय करके, कंटेनर को स्थानीय तौर पर टेस्ट करें.
with local_model.deploy_to_local_endpoint(
artifact_uri = 'model_artifacts/', # local path to artifacts
) as local_endpoint:
predict_response = local_endpoint.predict(
request_file='instances.json',
headers={"Content-Type": "application/json"},
)
health_check_response = local_endpoint.run_health_check()
अनुमान के नतीजे देखने के लिए, ये काम करें:
predict_response.content
7. Vertex AI में मॉडल डिप्लॉय करना
आपने स्थानीय तौर पर कंटेनर की जांच कर ली है, अब समय आ गया है कि इमेज को Artifact Registry में भेजें. इसके बाद, मॉडल को Vertex AI Model Registry में अपलोड करें.
सबसे पहले, आर्टफ़ैक्ट रजिस्ट्री को ऐक्सेस करने के लिए Docker को कॉन्फ़िगर करें.
!gcloud artifacts repositories create {REPOSITORY} --repository-format=docker \
--location=us-central1 --description="Docker repository"
!gcloud auth configure-docker {REGION}-docker.pkg.dev --quiet
इसके बाद, इमेज को पुश करें.
local_model.push_image()
इसके बाद, मॉडल अपलोड करें.
model = aiplatform.Model.upload(local_model = local_model,
display_name=MODEL_DISPLAY_NAME,
artifact_uri=f"{BUCKET_NAME}/{MODEL_ARTIFACT_DIR}",)
मॉडल अपलोड होने के बाद, आपको उसे कंसोल में दिखना चाहिए:
इसके बाद, मॉडल को डिप्लॉय करें, ताकि आप इसका इस्तेमाल ऑनलाइन अनुमान लगाने के लिए कर सकें. अनुमान लगाने के लिए कस्टम रूटीन, एक साथ कई अनुमान लगाने की सुविधा के साथ भी काम करते हैं. इसलिए, अगर आपके इस्तेमाल के उदाहरण में ऑनलाइन अनुमान लगाने की ज़रूरत नहीं है, तो आपको मॉडल को डिप्लॉय करने की ज़रूरत नहीं है.
endpoint = model.deploy(machine_type="n1-standard-2")
आखिर में, अनुमान पाकर डिप्लॉय किए गए मॉडल की जांच करें.
endpoint.predict(instances=[[0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43]])
🎉 बधाई हो! 🎉
आपने Vertex AI का इस्तेमाल करके, ये काम करने का तरीका जाना है:
- अनुमान लगाने के लिए कस्टम रूटीन की मदद से, डेटा को पहले से तैयार करने और बाद में प्रोसेस करने का कस्टम लॉजिक लिखना
Vertex AI के अलग-अलग हिस्सों के बारे में ज़्यादा जानने के लिए, दस्तावेज़ देखें.
8. साफ़-सफ़ाई सेवा
यदि आप इस लैब में बनाए गए नोटबुक का उपयोग करना जारी रखना चाहते हैं, तो यह अनुशंसा की जाती है कि आप उपयोग में नहीं होने पर इसे बंद कर दें. Google Cloud Console में Workbench के यूज़र इंटरफ़ेस (यूआई) से, नोटबुक चुनें. इसके बाद, रोकें को चुनें.
अगर आपको नोटबुक को पूरी तरह से मिटाना है, तो सबसे ऊपर दाईं ओर मौजूद मिटाएं बटन पर क्लिक करें.
डिप्लॉय किए गए एंडपॉइंट को मिटाने के लिए, कंसोल के एंडपॉइंट सेक्शन पर जाएं. इसके बाद, अपने बनाए गए एंडपॉइंट पर क्लिक करें और एंडपॉइंट से मॉडल को अनडिप्लॉय करें को चुनें:
कंटेनर इमेज मिटाने के लिए, Artifact Registry पर जाएं. इसके बाद, अपनी बनाई गई रिपॉज़िटरी चुनें और मिटाएं को चुनें
स्टोरेज बकेट मिटाने के लिए, अपने Cloud Console में नेविगेशन मेन्यू का इस्तेमाल करके, स्टोरेज पर जाएं. इसके बाद, अपनी बकेट चुनें और मिटाएं पर क्लिक करें:
