1. परिचय
इस लैब में, आपको Vertex AI पर कस्टम प्री-प्रोसेसिंग और पोस्ट-प्रोसेसिंग लॉजिक को लिखने के लिए, पसंद के मुताबिक अनुमान लगाने के रूटीन को इस्तेमाल करने का तरीका बताया जाएगा. इस सैंपल में, Scikit-learn का इस्तेमाल किया गया है, लेकिन ज़रूरत के हिसाब से अनुमान लगाने वाले रूटीन, XGBoost, PyTorch, और TensorFlow जैसे अन्य Python ML फ़्रेमवर्क के साथ काम कर सकते हैं.
आपको इनके बारे में जानकारी मिलेगी
- ज़रूरत के हिसाब से अनुमान लगाने वाले रूटीन की मदद से, अपने हिसाब से अनुमान लगाने वाला लॉजिक लिखें
- कस्टम सर्विंग कंटेनर और मॉडल की स्थानीय जांच करें
- Vertex AI अनुमान पर कस्टम सर्विंग कंटेनर की जांच करें
2. Vertex AI के बारे में जानकारी
यह लैब, Google Cloud पर उपलब्ध एआई (AI) प्रॉडक्ट के सबसे नए वर्शन का इस्तेमाल करती है. Vertex AI, Google Cloud के सभी मशीन लर्निंग प्लैटफ़ॉर्म को आसानी से डेवलप करने के लिए इंटिग्रेट करता है. पहले, AutoML और कस्टम मॉडल की मदद से ट्रेन किए गए मॉडल अलग-अलग सेवाओं से ऐक्सेस किए जा सकते थे. नई सेवा में, एक एपीआई से नए प्रॉडक्ट और इन दोनों का इस्तेमाल किया जा सकता है. आपके पास मौजूदा प्रोजेक्ट को Vertex AI पर माइग्रेट करने का विकल्प भी है.
Vertex AI में कई तरह के प्रॉडक्ट शामिल हैं, जो मशीन लर्निंग के वर्कफ़्लो को मैनेज करने में मदद करते हैं. इस लैब का फ़ोकस, अनुमानों और वर्कबेंच पर होगा.
3. इस्तेमाल के उदाहरण की खास जानकारी
इस लैब में, आपको फ़ॉरेस्ट रिग्रेशन मॉडल बनाने का एक रैंडम मॉडल बनाना है. इस मॉडल की मदद से, कटे हुए हीरे की कीमत, उसकी क्वालिटी, और साइज़ जैसे एट्रिब्यूट के आधार पर उसकी कीमत का अनुमान लगाया जा सकता है.
आपको कस्टम प्रीप्रोसेसिंग लॉजिक लिखना होगा, ताकि यह जांच की जा सके कि पेश करने के समय का डेटा, मॉडल के मुताबिक फ़ॉर्मैट में है या नहीं. अनुमानों को राउंड करने और उन्हें स्ट्रिंग में बदलने के लिए, आपको पोस्ट प्रोसेसिंग लॉजिक भी लिखना होगा. इस लॉजिक को लिखने के लिए, आपको सुझाव के लिए अपनी पसंद के मुताबिक रूटीन का इस्तेमाल करना होगा.
पसंद के मुताबिक अनुमान लगाने वाले रूटीन के बारे में जानकारी
Vertex AI में पहले से बने कंटेनर, मशीन लर्निंग फ़्रेमवर्क के हिसाब से अनुमान लगाकर, अनुमान लगाने के अनुरोधों को मैनेज करते हैं. कस्टम अनुमान लगाने वाले रूटीन से पहले, अगर आपको अनुमान लगाने से पहले इनपुट को प्रीप्रोसेस करना हो या नतीजा दिखाने से पहले मॉडल के अनुमान को पोस्टप्रोसेस करना हो, तो आपको एक कस्टम कंटेनर बनाना होगा.
कस्टम सर्विंग कंटेनर बनाने के लिए, एक ऐसा एचटीटीपी सर्वर बनाना ज़रूरी है जिसमें ट्रेन किए गए मॉडल को शामिल किया गया हो, एचटीटीपी अनुरोधों को मॉडल इनपुट में बदला गया हो, और मॉडल के आउटपुट को रिस्पॉन्स में बदला गया हो.
मनमुताबिक अनुमान लगाने वाले रूटीन की मदद से, Vertex AI आपके लिए सेवा से जुड़े कॉम्पोनेंट उपलब्ध कराता है, ताकि आप अपने मॉडल और डेटा ट्रांसफ़ॉर्मेशन पर फ़ोकस कर सकें.
आपको क्या बनाना होगा
आपको Target-vpc नाम से एक VPC नेटवर्क सेट अप करना है, जिसमें एक वर्कबेंच सबनेट शामिल हो. इस सबनेट का इस्तेमाल, उपयोगकर्ता की ओर से मैनेज की जाने वाली नोटबुक को डिप्लॉय करने के लिए किया जाता है. साथ ही, us-central1 में डिप्लॉय किए गए ऑनलाइन अनुमान और मॉडल एंडपॉइंट को ऐक्सेस किया जाता है. इस बारे में नीचे दी गई इमेज में दिखाया गया है.
Figure1
4. ट्यूटोरियल एपीआई चालू करें
पहला चरण: Compute Engine API चालू करना
Compute Engine पर जाएं और अगर यह पहले से चालू नहीं है, तो 'चालू करें' चुनें. आपको अपना notebook इंस्टेंस बनाने के लिए इसकी ज़रूरत होगी.
दूसरा चरण: Artifact Registry API को चालू करना
Artifact Registry पर जाएं और अगर पहले से ऐसा नहीं है, तो 'चालू करें' चुनें. पसंद के मुताबिक पेश करने वाला कंटेनर बनाने के लिए इसका इस्तेमाल किया जा सकता है.
तीसरा चरण: Vertex AI API को चालू करना
अपने Cloud Console के Vertex AI सेक्शन पर जाएं और 'Vertex AI API चालू करें' पर क्लिक करें.
चौथा चरण: Vertex AI Workbench इंस्टेंस बनाएं
अगर Notebooks API को पहले से चालू नहीं किया गया है, तो उसे चालू करें.
5. टारगेट-वीपीसी बनाएं
यह ट्यूटोरियल, Cloud Shell में gcloud कॉन्फ़िगरेशन लागू करने में मदद करने के लिए $variables का इस्तेमाल करता है.
Cloud Shell के अंदर, यह तरीका अपनाएं:
gcloud config list project
gcloud config set project [YOUR-PROJECT-NAME]
projectid=YOUR-PROJECT-NAME
echo $projectid
target-vpc बनाएं
Cloud Shell के अंदर, यह तरीका अपनाएं:
gcloud compute networks create aiml-vpc --project=$projectid --subnet-mode=custom
उपयोगकर्ता से मैनेज किया जाने वाला notebook सबनेट बनाना
Cloud Shell के अंदर, वर्कबेंच-सबनेट बनाएं.
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 का इस्तेमाल सॉफ़्टवेयर पैकेज डाउनलोड करने के लिए किया जाता है, क्योंकि उपयोगकर्ता की ओर से मैनेज की जाने वाली नोटबुक में बाहरी आईपी पता नहीं होता. Cloud 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 User की भूमिका के साथ अपडेट करें.
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 के अंदर निजी-क्लाइंट इंस्टेंस बनाएं.
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 बकेट में सेव करना होगा. अगर आपके प्रोजेक्ट में पहले से ही कोई बकेट है जिसका आपको इस्तेमाल करना है, तो इस चरण को छोड़ा जा सकता है.
लॉन्चर से, एक नया टर्मिनल सेशन खोलें.
अपने प्रोजेक्ट के लिए env वैरिएबल तय करने के लिए, अपने टर्मिनल से इन्हें चलाएं. साथ ही, अपने क्लाउड-प्रोजेक्ट को अपने प्रोजेक्ट के आईडी से बदलना न भूलें:
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
नोटबुक में, नीचे दिया गया कोड चिपकाएं.
सबसे पहले, ज़रूरी शर्तें.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
आपके डिप्लॉय किए गए मॉडल में डिपेंडेंसी का एक अलग सेट होगा, जो आपके notebook के एनवायरमेंट से पहले से इंस्टॉल होगा. इस वजह से, आपको Essentials.txt में मॉडल के लिए सभी डिपेंडेंसी की सूची बनानी होगी. इसके बाद, नोटबुक में वही डिपेंडेंसी इंस्टॉल करने के लिए पीआईपी (पिक्चर में पिक्चर) का इस्तेमाल करना होगा. इसके बाद, Vertex AI को डिप्लॉय करने से पहले, स्थानीय तौर पर मॉडल की जांच की जाएगी. इससे यह पक्का किया जा सकेगा कि सभी एनवायरमेंट एक-दूसरे से मेल खाते हैं या नहीं.
Pip, नोटबुक में डिपेंडेंसी इंस्टॉल करता है.
!pip install -U --user -r requirements.txt
ध्यान दें कि पीआईपी इंस्टॉल पूरा होने के बाद, आपको कर्नेल को रीस्टार्ट करना होगा.
इसके बाद, डायरेक्ट्री बनाएं जहां मॉडल और प्रीप्रोसेसिंग आर्टफ़ैक्ट को स्टोर करना है.
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}"
सीबोर्न लाइब्रेरी से डेटा लोड करें. इसके बाद, दो डेटा फ़्रेम बनाएं. पहला फ़्रेम, सुविधाओं के साथ और दूसरा लेबल के साथ.
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)
आइए, मॉडल को आज़माकर देखते हैं कि यह उम्मीद के मुताबिक काम कर रहा है या नहीं. मॉडल पर अनुमान लगाने का तरीका लागू करें, जो टेस्ट सैंपल पास कर रहा है.
my_pipeline.predict([[0.23, 'Ideal', 'E', 'SI2', 61.5, 55.0, 3.95, 3.98, 2.43]])
अब हम पाइपलाइन को Model_artifacts der में सेव कर सकते हैं और इसे 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"). पेश करते समय, हम यह जांच करना चाहते हैं कि इस सुविधा के लिए डेटा को छोटा भी किया गया है या नहीं. ऐसा इसलिए है, क्योंकि हमारे मॉडल को "FL" को एक हॉट एन्कोड करने का तरीका पता है लेकिन "फ़्लॉलेस" नहीं. आपको इस कस्टम प्री-प्रोसेसिंग लॉजिक को बाद में लिखना होगा. हालांकि, फ़िलहाल इस लुक अप टेबल को एक 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 अनुमान एक मॉडल सर्वर जनरेट करता है और आपके लिए एक कस्टम कंटेनर इमेज बनाता है.
कस्टम सर्विंग कंटेनर में कोड के ये तीन हिस्से होते हैं:
- मॉडल सर्वर (यह SDK टूल से अपने-आप जनरेट होगा और scr_mir/ में सेव होगा)
- मॉडल को होस्ट करने वाला एचटीटीपी सर्वर
- रूट, पोर्ट/वगैरह को सेट अप करने की जिम्मेदारी.
- यह किसी अनुरोध को मैनेज करने के वेब सर्वर से जुड़े पहलुओं के लिए ज़िम्मेदार होती है. जैसे, अनुरोध के मुख्य हिस्से को डीसीरियलाइज़ (पार्स) करना, जवाब को क्रम में लगाना, रिस्पॉन्स हेडर सेट करना वगैरह.
- इस उदाहरण में, SDK टूल में दिए गए डिफ़ॉल्ट हैंडलर, google.cloud.aiplatform.prediction.handler.प्रीमियम की सुविधा का इस्तेमाल किया जा सकता है.
- अनुमान के अनुरोध को प्रोसेस करने के लिए, एमएल लॉजिक की ज़िम्मेदारी इसकी है.
इनमें से हर कॉम्पोनेंट को, आपकी ज़रूरत के हिसाब से कस्टमाइज़ किया जा सकता है. इस उदाहरण में, सिर्फ़ अनुमान लगाने वाले को लागू किया जाएगा.
अनुमान लगाने वाला टूल, अनुमान के अनुरोध को प्रोसेस करने के लिए एमएल लॉजिक के लिए ज़िम्मेदार होता है. जैसे, कस्टम प्री-प्रोसेसिंग और पोस्ट-प्रोसेसिंग. कस्टम प्रेडिक्शन लॉजिक को लिखने के लिए, आपको Vertex AI प्रेडिक्टर इंटरफ़ेस को सब-क्लास करना होगा.
अनुमान लगाने के लिए पसंद के मुताबिक बनाए गए रूटीन की यह रिलीज़, फिर से इस्तेमाल किए जा सकने वाले XGBoost और Sklearn अनुमान लगाने वाले टूल के साथ उपलब्ध है. हालांकि, अगर आपको किसी दूसरे फ़्रेमवर्क का इस्तेमाल करने की ज़रूरत है, तो बेस प्रेडिक्शनर को सब-क्लास करके अपना खुद का फ़्रेमवर्क बनाया जा सकता है.
नीचे Sklearn अनुमान का एक उदाहरण दिया गया है. इस कस्टम मॉडल सर्वर को बनाने के लिए, आपको यही कोड लिखना होगा.
Sklearnअनजान पैरामीटर को सब-क्लास करने के लिए अपनी नोटबुक में नीचे दिया गया कोड चिपकाएं. इसके बाद, उसे src_mir/ में एक 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)]}
चलिए, इन तरीकों के बारे में ज़्यादा जानें.
- लोड करने का तरीका प्री-प्रोसेसिंग आर्टफ़ैक्ट में लोड होता है. इस मामले में, एक डिक्शनरी है, जिसमें हीरे की क्वालिटी की वैल्यू को उनके अब्रिविएशन के साथ मैप किया जाता है.
- प्रीप्रोसेस वाला तरीका उस आर्टफ़ैक्ट का इस्तेमाल करके यह पक्का करता है कि काम के समय पर, साफ़ तौर पर जानकारी देने वाली सुविधा छोटे फ़ॉर्मैट में हो. अगर नहीं, तो यह पूरी स्ट्रिंग को उसके छोटे रूप में बदल देता है.
- पोस्टप्रोसेस तरीका, अनुमानित वैल्यू को $ निशान वाली स्ट्रिंग के तौर पर दिखाता है और वैल्यू को राउंड करता है.
इसके बाद, इमेज बनाने के लिए 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 की मदद से, सवाल का जवाब देने वाला सिस्टम बनाना