1. परिचय
इस लैब में, आपको Vertex AI पर कस्टम अनुमान लगाने की रूटीन का इस्तेमाल करने का तरीका बताया जाएगा. इससे, कस्टम प्रीप्रोसेसिंग और पोस्टप्रोसेसिंग लॉजिक लिखा जा सकता है. इस सैंपल में Scikit-learn का इस्तेमाल किया गया है. हालांकि, कस्टम अनुमान रूटीन, Python ML के अन्य फ़्रेमवर्क के साथ भी काम कर सकते हैं. जैसे, XGBoost, PyTorch, और TensorFlow.
आपको क्या सीखने को मिलेगा
- कस्टम अनुमान की रूटीन का इस्तेमाल करके, अनुमान लगाने का लॉजिक अपनी पसंद के मुताबिक लिखना
- कस्टम सर्विंग कंटेनर और मॉडल को स्थानीय तौर पर टेस्ट करना
- Vertex AI Predictions पर कस्टम सर्विंग कंटेनर को टेस्ट करना
2. Vertex AI के बारे में जानकारी
इस लैब में, Google Cloud पर उपलब्ध एआई प्रॉडक्ट की नई सुविधा का इस्तेमाल किया जाता है. Vertex AI, Google Cloud के सभी एमएल प्रॉडक्ट को एक साथ इंटिग्रेट करता है, ताकि डेवलपर को बेहतर अनुभव मिल सके. पहले, AutoML और कस्टम मॉडल से ट्रेन किए गए मॉडल को अलग-अलग सेवाओं के ज़रिए ऐक्सेस किया जा सकता था. नए ऑफ़र में, इन दोनों को एक ही एपीआई में शामिल किया गया है. साथ ही, इसमें अन्य नए प्रॉडक्ट भी शामिल हैं. मौजूदा प्रोजेक्ट को भी Vertex AI पर माइग्रेट किया जा सकता है.
Vertex AI में कई अलग-अलग प्रॉडक्ट शामिल हैं, ताकि मशीन लर्निंग के वर्कफ़्लो को शुरू से लेकर आखिर तक सपोर्ट किया जा सके. इस लैब में, अनुमान और वर्कबेंच पर फ़ोकस किया जाएगा.
3. इस्तेमाल के उदाहरण की खास जानकारी
इस लैब में, आपको रैंडम फ़ॉरेस्ट रिग्रेशन मॉडल बनाना होगा. इससे कट, क्लैरिटी, और साइज़ जैसे एट्रिब्यूट के आधार पर हीरे की कीमत का अनुमान लगाया जा सकेगा.
आपको कस्टम प्रीप्रोसेसिंग लॉजिक लिखना होगा, ताकि यह पता चल सके कि मॉडल के हिसाब से, सेवा देने के समय डेटा सही फ़ॉर्मैट में है या नहीं. पूर्वानुमानों को पूर्णांक में बदलने और उन्हें स्ट्रिंग में बदलने के लिए, पोस्ट प्रोसेसिंग का कस्टम लॉजिक भी लिखा जाएगा. इस लॉजिक को लिखने के लिए, कस्टम अनुमान लगाने वाली रूटीन का इस्तेमाल किया जाएगा.
कस्टम अनुमान लगाने वाली रूटीन के बारे में जानकारी
Vertex AI के पहले से बने कंटेनर, मशीन लर्निंग फ़्रेमवर्क के अनुमान लगाने के ऑपरेशन को पूरा करके, अनुमान लगाने के अनुरोधों को मैनेज करते हैं. कस्टम अनुमान रूटीन से पहले, अगर आपको अनुमान लगाने से पहले इनपुट को प्रीप्रोसेस करना होता था या नतीजे दिखाने से पहले मॉडल के अनुमान को पोस्टप्रोसेस करना होता था, तो आपको कस्टम कंटेनर बनाना पड़ता था.
कस्टम सर्विंग कंटेनर बनाने के लिए, एक एचटीटीपी सर्वर लिखना होता है. यह सर्वर, ट्रेन किए गए मॉडल को रैप करता है. साथ ही, एचटीटीपी अनुरोधों को मॉडल इनपुट में बदलता है और मॉडल आउटपुट को जवाबों में बदलता है.
कस्टम अनुमान रूटीन की मदद से, Vertex AI आपको अनुमान से जुड़े कॉम्पोनेंट उपलब्ध कराता है, ताकि आप अपने मॉडल और डेटा ट्रांसफ़ॉर्मेशन पर ध्यान दे सकें.
आपको क्या बनाने को मिलेगा
आपको aiml-vpc नाम का एक वीपीसी नेटवर्क सेट अप करना होगा. इसमें एक वर्कबेंच सबनेट होगा, जिसका इस्तेमाल उपयोगकर्ता के मैनेज किए गए नोटबुक को डिप्लॉय करने के लिए किया जाएगा. साथ ही, इसमें us-central1 में डिप्लॉय किए गए ऑनलाइन अनुमान और मॉडल एंडपॉइंट को ऐक्सेस किया जाएगा. इसे नीचे दिए गए फ़िगर1 में दिखाया गया है.
Figure1
4. ट्यूटोरियल वाले एपीआई चालू करना
पहला चरण: Compute Engine API को चालू करना
Compute Engine पर जाएं. अगर यह पहले से चालू नहीं है, तो इसे चालू करें. आपको नोटबुक इंस्टेंस बनाने के लिए इसकी ज़रूरत होगी.
दूसरा चरण: Artifact Registry API चालू करना
Artifact Registry पर जाएं. अगर यह पहले से चालू नहीं है, तो इसे चालू करें. इसका इस्तेमाल, पसंद के मुताबिक सर्वर कंटेनर बनाने के लिए किया जाएगा.
तीसरा चरण: Vertex AI API चालू करना
Cloud Console के Vertex AI सेक्शन पर जाएं और 'Vertex AI API चालू करें' पर क्लिक करें.
चौथा चरण: Vertex AI Workbench इंस्टेंस बनाना
अगर Notebooks API पहले से चालू नहीं है, तो इसे चालू करें.
5. aiml-vpc बनाएं
इस ट्यूटोरियल में, Cloud Shell में gcloud कॉन्फ़िगरेशन लागू करने में मदद के लिए, $variables का इस्तेमाल किया गया है.
Cloud Shell में, यह तरीका अपनाएं:
gcloud config list project
gcloud config set project [YOUR-PROJECT-NAME]
projectid=YOUR-PROJECT-NAME
echo $projectid
aiml-vpc बनाना
Cloud Shell में, यह तरीका अपनाएं:
gcloud compute networks create aiml-vpc --project=$projectid --subnet-mode=custom
उपयोगकर्ता के मैनेज किए गए नोटबुक सबनेट बनाना
Cloud Shell में, workbench-subnet बनाएं.
gcloud compute networks subnets create workbench-subnet --project=$projectid --range=172.16.10.0/28 --network=aiml-vpc --region=us-central1 --enable-private-ip-google-access
क्लाउड राऊटर और एनएटी कॉन्फ़िगरेशन
इस ट्यूटोरियल में सॉफ़्टवेयर पैकेज डाउनलोड करने के लिए, Cloud NAT का इस्तेमाल किया जाता है. ऐसा इसलिए, क्योंकि उपयोगकर्ता के मैनेज किए जा रहे नोटबुक का कोई बाहरी आईपी पता नहीं होता. Cloud NAT, इग्रेस NAT की सुविधाएं देता है. इसका मतलब है कि इंटरनेट होस्ट को, उपयोगकर्ता के मैनेज किए गए नोटबुक से कम्यूनिकेशन शुरू करने की अनुमति नहीं है. इससे यह ज़्यादा सुरक्षित हो जाता है.
Cloud Shell में, us-central1 रीजनल क्लाउड राउटर बनाएं.
gcloud compute routers create cloud-router-us-central1-aiml-nat --network aiml-vpc --region us-central1
Cloud Shell में, us-central1 रीजनल क्लाउड नेट गेटवे बनाएं.
gcloud compute routers nats create cloud-nat-us-central1 --router=cloud-router-us-central1-aiml-nat --auto-allocate-nat-external-ips --nat-all-subnet-ip-ranges --region us-central1
6. उपयोगकर्ता के मैनेज किए गए नोटबुक को बनाना
उपयोगकर्ता के मैनेज किए गए सेवा खाते (नोटबुक) को बनाना
इस सेक्शन में, आपको उपयोगकर्ता के मैनेज किए गए सेवा खाते को बनाना होगा. यह खाता, ट्यूटोरियल में इस्तेमाल किए गए Vertex Workbench (Notebook) से जुड़ा होगा.
ट्यूटोरियल में, सेवा खाते पर ये नियम लागू होंगे:
Cloud Shell में, सेवा खाता बनाएं.
gcloud iam service-accounts create user-managed-notebook-sa \
--display-name="user-managed-notebook-sa"
Cloud Shell में, सेवा खाते को स्टोरेज एडमिन की भूमिका के साथ अपडेट करें.
gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:user-managed-notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/storage.admin"
Cloud Shell में, सेवा खाते को Vertex AI उपयोगकर्ता की भूमिका के साथ अपडेट करें.
gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:user-managed-notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/aiplatform.user"
Cloud Shell में, सेवा खाते को Artifact Registry एडमिन की भूमिका असाइन करें.
gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:user-managed-notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/artifactregistry.admin"
Cloud Shell में, सेवा खाते की सूची बनाएं. साथ ही, उस ईमेल पते को नोट करें जिसका इस्तेमाल उपयोगकर्ता के मैनेज किए गए नोटबुक को बनाते समय किया जाएगा.
gcloud iam service-accounts list
उपयोगकर्ता के मैनेज किए गए नोटबुक को बनाना
यहां दिए गए सेक्शन में, उपयोगकर्ता के मैनेज किए गए ऐसे नोटबुक का इंस्टेंस बनाएं जिसमें पहले से बनाया गया सेवा खाता, user-managed-notebook-sa शामिल हो.
Cloud Shell में, private-client इंस्टेंस बनाएं.
gcloud notebooks instances create workbench-tutorial \
--vm-image-project=deeplearning-platform-release \
--vm-image-family=common-cpu-notebooks \
--machine-type=n1-standard-4 \
--location=us-central1-a \
--shielded-secure-boot \
--subnet-region=us-central1 \
--subnet=workbench-subnet \
--no-public-ip --service-account=user-managed-notebook-sa@$projectid.iam.gserviceaccount.com
7. ट्रेनिंग कोड लिखना
पहला चरण: क्लाउड स्टोरेज बकेट बनाना
मॉडल और प्रीप्रोसेसिंग आर्टफ़ैक्ट को 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.1.1
numpy>=1.17.3, <1.24.0
scikit-learn~=1.0.0
pandas
google-cloud-storage>=2.2.1,<3.0.0dev
google-cloud-aiplatform[prediction]>=1.18.2
आपके डिप्लॉय किए गए मॉडल में, नोटबुक एनवायरमेंट की तुलना में पहले से इंस्टॉल की गई डिपेंडेंसी का अलग सेट होगा. इस वजह से, आपको requirements.txt फ़ाइल में मॉडल के लिए सभी डिपेंडेंसी की सूची बनानी होगी. इसके बाद, नोटबुक में ठीक वही डिपेंडेंसी इंस्टॉल करने के लिए pip का इस्तेमाल करना होगा. बाद में, मॉडल को Vertex AI पर डिप्लॉय करने से पहले, स्थानीय तौर पर टेस्ट किया जाएगा. इससे यह पक्का किया जा सकेगा कि एनवायरमेंट एक जैसे हैं.
Pip, नोटबुक में डिपेंडेंसी इंस्टॉल करता है.
!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(sparse=False), [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"}
हमारे ट्रेनिंग डेटा में, क्लैरिटी की जानकारी हमेशा छोटे रूप में दी गई थी. जैसे, "बेहतरीन" के बजाय "बी". हम यह जांच करना चाहते हैं कि इस सुविधा के लिए डेटा को छोटा किया गया है या नहीं. ऐसा इसलिए है, क्योंकि हमारे मॉडल को "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
8. सीपीआर मॉडल सर्वर का इस्तेमाल करके, कस्टम सर्विंग कंटेनर बनाना
मॉडल को ट्रेन कर लिया गया है और प्रीप्रोसेसिंग आर्टफ़ैक्ट सेव कर लिया गया है. अब कस्टम सर्विंग कंटेनर बनाने का समय है. आम तौर पर, मॉडल सर्वर कोड लिखकर ही सर्विंग कंटेनर बनाया जाता है. हालांकि, अनुमान लगाने की कस्टम रूटीन की मदद से, Vertex AI Predictions एक मॉडल सर्वर जनरेट करता है और आपके लिए कस्टम कंटेनर इमेज बनाता है.
कस्टम सर्वरिंग कंटेनर में, ये तीन कोड होते हैं:
- मॉडल सर्वर (यह SDK टूल से अपने-आप जनरेट होगा और इसे scr_dir/ में सेव किया जाएगा)
- मॉडल को होस्ट करने वाला एचटीटीपी सर्वर
- रास्ते/पोर्ट/वगैरह सेट अप करने के लिए ज़िम्मेदार.
- यह कुकी, अनुरोध को मैनेज करने के लिए वेबसर्वर के पहलुओं के लिए ज़िम्मेदार होती है. जैसे, अनुरोध के मुख्य हिस्से को डिसिरियलाइज़ करना, जवाब को सीरियललाइज़ करना, जवाब के हेडर सेट करना वगैरह.
- इस उदाहरण में, SDK में दिए गए डिफ़ॉल्ट हैंडलर, google.cloud.aiplatform.prediction.handler.PredictionHandler का इस्तेमाल किया जाएगा.
- यह कुकी, अनुमान लगाने के अनुरोध को प्रोसेस करने के लिए एमएल लॉजिक के लिए ज़िम्मेदार होती है.
इनमें से हर कॉम्पोनेंट को, इस्तेमाल के उदाहरण की ज़रूरतों के हिसाब से पसंद के मुताबिक बनाया जा सकता है. इस उदाहरण में, सिर्फ़ अनुमान लगाने वाले फ़ंक्शन को लागू किया जाएगा.
अनुमान लगाने वाले फ़ंक्शन की ज़िम्मेदारी, अनुमान लगाने के अनुरोध को प्रोसेस करने के लिए एमएल लॉजिक तय करना है. जैसे, कस्टम प्रीप्रोसेसिंग और पोस्टप्रोसेसिंग. अनुमान लगाने के लिए, पसंद के मुताबिक लॉजिक लिखने के लिए, आपको Vertex AI Predictor इंटरफ़ेस का सबक्लास बनाना होगा.
कस्टम अनुमान लगाने की रूटीन की इस रिलीज़ में, दोबारा इस्तेमाल किए जा सकने वाले XGBoost और Sklearn अनुमान लगाने वाले टूल शामिल हैं. हालांकि, अगर आपको किसी दूसरे फ़्रेमवर्क का इस्तेमाल करना है, तो अनुमान लगाने वाले बेस टूल की सबक्लास बनाकर अपना टूल बनाया जा सकता है.
Sklearn predictor का एक उदाहरण यहां दिया गया है. कस्टम मॉडल सर्वर बनाने के लिए, आपको इतना ही कोड लिखना होगा.
SklearnPredictor को सबक्लास करने के लिए, अपनी नोटबुक में यहां दिया गया कोड चिपकाएं. साथ ही, इसे src_dir/ में मौजूद Python फ़ाइल में लिखें. ध्यान दें कि इस उदाहरण में, हम सिर्फ़ लोड, प्रीप्रोसेस, और पोस्टप्रोसेस करने के तरीकों को पसंद के मुताबिक बना रहे हैं. हम अनुमान लगाने के तरीके को पसंद के मुताबिक नहीं बना रहे हैं.
%%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)]}
आइए, इन सभी तरीकों के बारे में ज़्यादा जानें.
- लोड करने का तरीका, प्रीप्रोसेसिंग आर्टफ़ैक्ट को लोड करता है. इस मामले में, यह एक डिक्शनरी है जो डायमंड की क्लैरिटी की वैल्यू को उनके छोटे किए गए नामों पर मैप करती है.
- प्रीप्रोसेस करने का तरीका, उस आर्टफ़ैक्ट का इस्तेमाल करता है. इससे यह पक्का किया जाता है कि सेवा देने के समय, जवाब को छोटा करने की सुविधा, छोटे किए गए फ़ॉर्मैट में हो. अगर ऐसा नहीं है, तो यह पूरी स्ट्रिंग को उसके संक्षिप्त रूप में बदल देता है.
- 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
9. मॉडल को 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 का इस्तेमाल करके ये काम करने का तरीका सीखा है:
- कस्टम अनुमान रूटीन की मदद से, प्रीप्रोसेसिंग और पोस्टप्रोसेसिंग के लिए अपनी पसंद के मुताबिक लॉजिक लिखना
Cosmopup को कोडलैब बहुत पसंद हैं!!
आगे क्या करना है?
ज़्यादा जानकारी और वीडियो
- Vertex AI क्या है?
- Vertex AI का इस्तेमाल शुरू करना
- Vertex AI पर मौजूद कौनसा एआई/एमएल सलूशन मेरे लिए सही है?
- Vertex AI की मदद से, सवालों के जवाब देने वाला सिस्टम बनाना