1. खास जानकारी
इस लैब में, आपको Vertex AI पर कस्टम अनुमान लगाने की रूटीन का इस्तेमाल करने का तरीका बताया जाएगा. इससे, कस्टम प्रीप्रोसेसिंग और पोस्टप्रोसेसिंग लॉजिक लिखा जा सकता है. इस सैंपल में Scikit-learn का इस्तेमाल किया गया है. हालांकि, कस्टम अनुमान रूटीन, Python ML के अन्य फ़्रेमवर्क के साथ भी काम कर सकते हैं. जैसे, XGBoost, PyTorch, और TensorFlow.
आपको ये सब सीखने को मिलेगा
आपको, इनके बारे में जानकारी मिलेगी:
- कस्टम अनुमान की रूटीन का इस्तेमाल करके, अनुमान लगाने का लॉजिक अपनी पसंद के मुताबिक लिखना
- कस्टम सर्विंग कंटेनर और मॉडल को स्थानीय तौर पर टेस्ट करना
- Vertex AI Predictions पर कस्टम सर्विंग कंटेनर को टेस्ट करना
Google Cloud पर इस लैब को चलाने की कुल लागत करीब 100 रुपये है.
2. Vertex AI के बारे में जानकारी
इस लैब में, Google Cloud पर उपलब्ध एआई प्रॉडक्ट की नई सुविधा का इस्तेमाल किया जाता है. 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 सेक्शन में जाकर, Workbench पर क्लिक करें:
अगर Notebooks API पहले से चालू नहीं है, तो इसे चालू करें.
चालू होने के बाद, उदाहरण पर क्लिक करें. इसके बाद, नया बनाएं को चुनें.
डिफ़ॉल्ट विकल्पों को स्वीकार करें और बनाएं पर क्लिक करें.
जब इंस्टेंस तैयार हो जाए, तो उसे खोलने के लिए JUPYTERLAB खोलें पर क्लिक करें.
5. ट्रेनिंग कोड लिखना
पहला चरण: क्लाउड स्टोरेज बकेट बनाना
मॉडल और प्रीप्रोसेसिंग आर्टफ़ैक्ट को Cloud Storage बकेट में सेव किया जाएगा. अगर आपके प्रोजेक्ट में पहले से ही कोई ऐसा बकेट है जिसका आपको इस्तेमाल करना है, तो इस चरण को छोड़ा जा सकता है.
लॉन्चर से, नया टर्मिनल सेशन खोलें.
अपने टर्मिनल से, अपने प्रोजेक्ट के लिए एनवायरमेंट वैरिएबल तय करने के लिए, यहां दिया गया कमांड चलाएं. साथ ही, यह पक्का करें कि आपने your-cloud-project की जगह अपने प्रोजेक्ट का आईडी डाला हो:
PROJECT_ID='your-cloud-project'
इसके बाद, अपने प्रोजेक्ट में नया बकेट बनाने के लिए, अपने टर्मिनल में यह कमांड चलाएं.
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 install -U --user -r requirements.txt
ध्यान दें कि pip install पूरा होने के बाद, आपको कर्नल को रीस्टार्ट करना होगा.
इसके बाद, उन डायरेक्ट्री को बनाएं जहां आपको मॉडल और प्रीप्रोसेसिंग आर्टफ़ैक्ट सेव करने हैं.
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" के बजाय "Flawless". हम यह जांच करना चाहते हैं कि इस सुविधा के लिए डेटा को छोटा किया गया है या नहीं. ऐसा इसलिए है, क्योंकि हमारे मॉडल को "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 predictor का एक उदाहरण यहां दिया गया है. कस्टम मॉडल सर्वर बनाने के लिए, आपको इतना ही कोड लिखना होगा.
अपनी नोटबुक में, यहां दिया गया कोड चिपकाएं. इससे 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 में अपलोड करने का समय है.
सबसे पहले, Artifact 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 में नेविगेशन मेन्यू का इस्तेमाल करके, स्टोरेज पर जाएं. इसके बाद, अपनी बकेट चुनें और मिटाएं पर क्लिक करें:
