1. खास जानकारी
इस लैब में, आपको Vertex AI के इस्तेमाल का तरीका बताया जाएगा. यह Google Cloud का मैनेज किया जा रहा नया एमएल प्लैटफ़ॉर्म है. इसे पूरी तरह से मशीन लर्निंग के वर्कफ़्लो बनाने के लिए इस्तेमाल किया जाता है. इस लेख में, आपको रॉ डेटा के बजाय डिप्लॉय किए गए मॉडल बनाने का तरीका बताया जाएगा. साथ ही, आप Vertex AI की मदद से अपने मशीन लर्निंग प्रोजेक्ट को डेवलप करने और प्रोडक्शन के लिए, इस वर्कशॉप को तैयार कर देंगे. इस लैब में, हम Cloud Shell का इस्तेमाल करके कस्टम Docker इमेज बना रहे हैं, ताकि Vertex AI की मदद से ट्रेनिंग देने के लिए कस्टम कंटेनर को दिखाया जा सके.
इसलिए, यहां मॉडल कोड के लिए TensorFlow का इस्तेमाल किया जा रहा है. हालांकि, आपके पास इसे आसानी से किसी दूसरे फ़्रेमवर्क से बदलने का विकल्प है.
आपको ये सब सीखने को मिलेगा
आपको, इनके बारे में जानकारी मिलेगी:
- Cloud Shell का इस्तेमाल करके, मॉडल ट्रेनिंग कोड बनाएं और उसे कंटेनर में रखें
- Vertex AI में कस्टम मॉडल ट्रेनिंग जॉब सबमिट करना
- अपने ट्रेन किए गए मॉडल को एंडपॉइंट पर डिप्लॉय करें. साथ ही, अनुमान पाने के लिए उस एंडपॉइंट का इस्तेमाल करें
Google Cloud पर इस लैब को चलाने की कुल लागत करीब $2 है.
2. Vertex AI के बारे में जानकारी
यह लैब, Google Cloud पर उपलब्ध एआई (AI) प्रॉडक्ट के सबसे नए वर्शन का इस्तेमाल करती है. Vertex AI, Google Cloud के सभी मशीन लर्निंग प्लैटफ़ॉर्म को आसानी से डेवलप करने के लिए इंटिग्रेट करता है. पहले, AutoML और कस्टम मॉडल की मदद से ट्रेन किए गए मॉडल अलग-अलग सेवाओं से ऐक्सेस किए जा सकते थे. नई सेवा में, एक एपीआई से नए प्रॉडक्ट और इन दोनों का इस्तेमाल किया जा सकता है. आपके पास मौजूदा प्रोजेक्ट को Vertex AI पर माइग्रेट करने का विकल्प भी है. अगर आपका कोई सुझाव, राय या शिकायत है, तो कृपया सहायता पेज पर जाएं.
Vertex में एमएल वर्कफ़्लो के हर चरण में आपकी मदद करने के लिए, कई अलग-अलग टूल शामिल हैं. इनकी मदद से, नीचे दिए गए डायग्राम में देखा जा सकता है. हम Vertex ट्रेनिंग और पूर्वानुमान के इस्तेमाल पर फ़ोकस करेंगे, जिसे नीचे हाइलाइट किया गया है.
3. अपना एनवायरमेंट सेट अप करें
अपने हिसाब से एनवायरमेंट सेटअप करें
Cloud Console में साइन इन करें और नया प्रोजेक्ट बनाएं या किसी मौजूदा प्रोजेक्ट का फिर से इस्तेमाल करें. (अगर आपके पास पहले से Gmail या Google Workspace खाता नहीं है, तो आपको एक खाता बनाना होगा.)
प्रोजेक्ट आईडी याद रखें. यह Google Cloud के सभी प्रोजेक्ट के लिए एक खास नाम होता है (ऊपर दिया गया नाम पहले ही ले लिया गया है और यह आपके लिए काम नहीं करेगा!).
इसके बाद, आपको Google Cloud के संसाधनों का इस्तेमाल करने के लिए, Cloud Console में बिलिंग की सुविधा चालू करनी होगी.
इस कोडलैब का इस्तेमाल करने पर, आपको ज़्यादा पैसे नहीं चुकाने होंगे. "साफ़ करना" सेक्शन में दिए गए निर्देशों का पालन करना न भूलें सेक्शन में, संसाधनों को बंद करने का तरीका बताया गया है. इससे इस ट्यूटोरियल के अलावा बिलिंग की सुविधा नहीं मिलेगी. Google Cloud के नए उपयोगकर्ता, 300 डॉलर के मुफ़्त ट्रायल वाले प्रोग्राम में हिस्सा ले सकते हैं.
पहला चरण: 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
कमांड आउटपुट
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
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 में ट्रेनिंग जॉब चलाने के लिए, हमें सेव की गई मॉडल एसेट को सेव करने के लिए एक स्टोरेज बकेट की ज़रूरत होगी. बकेट बनाने के लिए, अपने Cloud Shell टर्मिनल में ये कमांड चलाएं:
BUCKET_NAME=gs://$GOOGLE_CLOUD_PROJECT-bucket
gsutil mb -l us-central1 $BUCKET_NAME
चरण 4: Alias Python 3
इस लैब में मौजूद कोड, Python 3 का इस्तेमाल करता है. यह पक्का करने के लिए कि इस लैब में बनाई जाने वाली स्क्रिप्ट को चलाते समय आप Python 3 का इस्तेमाल करें, Cloud Shell में इन्हें चलाकर एक उपनाम बनाएं:
alias python=python3
इस लैब में जिस मॉडल को ट्रेनिंग दी जाएगी और जो उसे इस्तेमाल किया जाएगा उसे TensorFlow के दस्तावेज़ में दिए गए इस ट्यूटोरियल पर बनाया गया है. इस ट्यूटोरियल में, Kaggle के Auto MPG डेटासेट का इस्तेमाल करके, वाहन की ईंधन की खपत का अनुमान लगाया जाता है.
4. ट्रेनिंग कोड को कंटेनर में बदलें
हम अपने ट्रेनिंग कोड को Docker कंटेनर में डालकर और इस कंटेनर को Google Container Registry में भेजकर, इस ट्रेनिंग जॉब को Vertex में सबमिट कर देंगे. इस तरीके का इस्तेमाल करके, हम किसी भी फ़्रेमवर्क के साथ बनाए गए मॉडल को ट्रेनिंग दे सकते हैं.
पहला चरण: फ़ाइलें सेट अप करना
शुरू करने के लिए, Cloud Shell के टर्मिनल से, नीचे दिए गए निर्देशों का पालन करके, Docker कंटेनर के लिए ज़रूरी फ़ाइलें बनाएं:
mkdir mpg
cd mpg
touch Dockerfile
mkdir trainer
touch trainer/train.py
अब आपके पास एक mpg/ डायरेक्ट्री होनी चाहिए, जो इस तरह दिखती है:
+ Dockerfile
+ trainer/
+ train.py
इन फ़ाइलों को देखने और उनमें बदलाव करने के लिए, हम Cloud Shell में पहले से मौजूद कोड एडिटर का इस्तेमाल करेंगे. Cloud Shell में, सबसे ऊपर दाईं ओर मौजूद मेन्यू बार पर मौजूद बटन पर क्लिक करके, एडिटर और टर्मिनल के बीच स्विच और स्विच किया जा सकता है:
दूसरा चरण: Dockerfile बनाएं
अपने कोड को कंटेनर बनाने के लिए, हमें पहले Dockerfile बनाना होगा. हम Dockerfile में, इमेज को चलाने के लिए ज़रूरी सभी निर्देशों को शामिल करते हैं. यह उन सभी लाइब्रेरी को इंस्टॉल करेगा जिनका हम इस्तेमाल कर रहे हैं. साथ ही, यह हमारे ट्रेनिंग कोड के लिए एंट्री पॉइंट सेट अप करेगा.
Cloud Shell फ़ाइल एडिटर में जाकर, अपनी mpg/ डायरेक्ट्री खोलें. इसके बाद, Dockerfile खोलने के लिए, दो बार क्लिक करें:
इसके बाद, इस फ़ाइल में इन्हें कॉपी करें:
FROM gcr.io/deeplearning-platform-release/tf2-cpu.2-3
WORKDIR /
# Copies the trainer code to the docker image.
COPY trainer /trainer
# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "-m", "trainer.train"]
यह Dockerfile, डीप लर्निंग कंटेनर TensorFlow Enterprise 2.3 Docker इमेज का इस्तेमाल करता है. Google Cloud पर डीप लर्निंग कंटेनर में, कई सामान्य एमएल और डेटा साइंस फ़्रेमवर्क पहले से इंस्टॉल होते हैं. हम TF Enterprise 2.3, Pandas, Scikit-learn, और अन्य प्लैटफ़ॉर्म का इस्तेमाल कर रहे हैं. इमेज को डाउनलोड करने के बाद, Dockerfile हमारे ट्रेनिंग कोड के लिए एंट्रीपॉइंट सेट अप करता है. इसे हम अगले चरण में जोड़ेंगे.
तीसरा चरण: मॉडल ट्रेनिंग कोड जोड़ना
क्लाउड शेल एडिटर से, इसके बाद train.py फ़ाइल खोलें और नीचे दिए गए कोड को कॉपी करें (यह TensorFlow दस्तावेज़ में दिए गए ट्यूटोरियल से लिया गया है.
# This will be replaced with your bucket name after running the `sed` command in the tutorial
BUCKET = "BUCKET_NAME"
import numpy as np
import pandas as pd
import pathlib
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
print(tf.__version__)
"""## The Auto MPG dataset
The dataset is available from the [UCI Machine Learning Repository](https://archive.ics.uci.edu/ml/).
### Get the data
First download the dataset.
"""
"""Import it using pandas"""
dataset_path = "https://storage.googleapis.com/io-vertex-codelab/auto-mpg.csv"
dataset = pd.read_csv(dataset_path, na_values = "?")
dataset.tail()
"""### Clean the data
The dataset contains a few unknown values.
"""
dataset.isna().sum()
"""To keep this initial tutorial simple drop those rows."""
dataset = dataset.dropna()
"""The `"origin"` column is really categorical, not numeric. So convert that to a one-hot:"""
dataset['origin'] = dataset['origin'].map({1: 'USA', 2: 'Europe', 3: 'Japan'})
dataset = pd.get_dummies(dataset, prefix='', prefix_sep='')
dataset.tail()
"""### Split the data into train and test
Now split the dataset into a training set and a test set.
We will use the test set in the final evaluation of our model.
"""
train_dataset = dataset.sample(frac=0.8,random_state=0)
test_dataset = dataset.drop(train_dataset.index)
"""### Inspect the data
Have a quick look at the joint distribution of a few pairs of columns from the training set.
Also look at the overall statistics:
"""
train_stats = train_dataset.describe()
train_stats.pop("mpg")
train_stats = train_stats.transpose()
train_stats
"""### Split features from labels
Separate the target value, or "label", from the features. This label is the value that you will train the model to predict.
"""
train_labels = train_dataset.pop('mpg')
test_labels = test_dataset.pop('mpg')
"""### Normalize the data
Look again at the `train_stats` block above and note how different the ranges of each feature are.
It is good practice to normalize features that use different scales and ranges. Although the model *might* converge without feature normalization, it makes training more difficult, and it makes the resulting model dependent on the choice of units used in the input.
Note: Although we intentionally generate these statistics from only the training dataset, these statistics will also be used to normalize the test dataset. We need to do that to project the test dataset into the same distribution that the model has been trained on.
"""
def norm(x):
return (x - train_stats['mean']) / train_stats['std']
normed_train_data = norm(train_dataset)
normed_test_data = norm(test_dataset)
"""This normalized data is what we will use to train the model.
Caution: The statistics used to normalize the inputs here (mean and standard deviation) need to be applied to any other data that is fed to the model, along with the one-hot encoding that we did earlier. That includes the test set as well as live data when the model is used in production.
## The model
### Build the model
Let's build our model. Here, we'll use a `Sequential` model with two densely connected hidden layers, and an output layer that returns a single, continuous value. The model building steps are wrapped in a function, `build_model`, since we'll create a second model, later on.
"""
def build_model():
model = keras.Sequential([
layers.Dense(64, activation='relu', input_shape=[len(train_dataset.keys())]),
layers.Dense(64, activation='relu'),
layers.Dense(1)
])
optimizer = tf.keras.optimizers.RMSprop(0.001)
model.compile(loss='mse',
optimizer=optimizer,
metrics=['mae', 'mse'])
return model
model = build_model()
"""### Inspect the model
Use the `.summary` method to print a simple description of the model
"""
model.summary()
"""Now try out the model. Take a batch of `10` examples from the training data and call `model.predict` on it.
It seems to be working, and it produces a result of the expected shape and type.
### Train the model
Train the model for 1000 epochs, and record the training and validation accuracy in the `history` object.
Visualize the model's training progress using the stats stored in the `history` object.
This graph shows little improvement, or even degradation in the validation error after about 100 epochs. Let's update the `model.fit` call to automatically stop training when the validation score doesn't improve. We'll use an *EarlyStopping callback* that tests a training condition for every epoch. If a set amount of epochs elapses without showing improvement, then automatically stop the training.
You can learn more about this callback [here](https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/EarlyStopping).
"""
model = build_model()
EPOCHS = 1000
# The patience parameter is the amount of epochs to check for improvement
early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', patience=10)
early_history = model.fit(normed_train_data, train_labels,
epochs=EPOCHS, validation_split = 0.2,
callbacks=[early_stop])
# Export model and save to GCS
model.save(BUCKET + '/mpg/model')
ऊपर दिए गए कोड को mpg/trainer/train.py फ़ाइल में कॉपी करने के बाद, अपने क्लाउड शेल के टर्मिनल पर वापस जाएं. इसके बाद, फ़ाइल में बकेट का नाम जोड़ने के लिए, यहां दिया गया कमांड चलाएं:
sed -i "s|BUCKET_NAME|$BUCKET_NAME|g" trainer/train.py
चौथा चरण: कंटेनर बनाना और उसकी जांच करना
अपने Terminal से, Google Container Registry में अपनी कंटेनर इमेज के यूआरआई के साथ वैरिएबल तय करने के लिए इन्हें चलाएं:
IMAGE_URI="gcr.io/$GOOGLE_CLOUD_PROJECT/mpg:v1"
इसके बाद, अपनी mpg डायरेक्ट्री के रूट से नीचे दिए गए निर्देशों को चलाकर कंटेनर बनाएं:
docker build ./ -t $IMAGE_URI
कंटेनर बनाने के बाद, उसे Google Container Registry में भेजें:
docker push $IMAGE_URI
यह पुष्टि करने के लिए कि आपकी इमेज कंटेनर रजिस्ट्री में पुश की गई है या नहीं, आपको अपने कंसोल के कंटेनर रजिस्ट्री सेक्शन में जाने पर ऐसा कुछ दिखेगा:
कंटेनर रजिस्ट्री में भेजे जाने के बाद, हम एक कस्टम मॉडल ट्रेनिंग जॉब शुरू करने के लिए तैयार हैं.
5. Vertex AI में ट्रेनिंग जॉब चलाएं
Vertex आपको ट्रेनिंग मॉडल के लिए दो विकल्प देता है:
- AutoML: कम मेहनत और एमएल विशेषज्ञता की मदद से, अच्छी क्वालिटी के मॉडल को ट्रेनिंग दें.
- पसंद के मुताबिक ट्रेनिंग: Google Cloud के पहले से बने किसी कंटेनर या अपने कंटेनर का इस्तेमाल करके, कस्टम ट्रेनिंग ऐप्लिकेशन को क्लाउड में चलाएं.
इस लैब में, हम Google कंटेनर रजिस्ट्री पर मौजूद अपने कस्टम कंटेनर के ज़रिए, कस्टम ट्रेनिंग का इस्तेमाल कर रहे हैं. शुरू करने के लिए, अपने Cloud Console के Vertex सेक्शन में, ट्रेनिंग सेक्शन पर जाएं:
पहला चरण: ट्रेनिंग शुरू करना
अपने ट्रेनिंग जॉब और डिप्लॉय किए गए मॉडल के पैरामीटर डालने के लिए, बनाएं पर क्लिक करें:
- डेटासेट में जाकर, मैनेज किया जा रहा कोई डेटासेट नहीं है चुनें
- इसके बाद, ट्रेनिंग के तरीके के तौर पर कस्टम ट्रेनिंग (ऐडवांस) चुनें और जारी रखें पर क्लिक करें.
- मॉडल का नाम के लिए
mpg(या जिसे भी आप अपने मॉडल को पुकारना चाहते हैं) डालें - जारी रखें पर क्लिक करें
कंटेनर सेटिंग चरण में, कस्टम कंटेनर चुनें:
पहले बॉक्स (कंटेनर इमेज) में, ब्राउज़ करें पर क्लिक करें. इसके बाद, वह कंटेनर ढूंढें जिसे आपने अभी-अभी कंटेनर रजिस्ट्री में पुश किया है. यह कुछ ऐसी नज़र आनी चाहिए:
बाकी फ़ील्ड को खाली छोड़ दें और जारी रखें पर क्लिक करें.
हम इस ट्यूटोरियल में हाइपर पैरामीटर ट्यूनिंग का इस्तेमाल नहीं करेंगे. इसलिए, 'हाइपर पैरामीटर ट्यूनिंग चालू करें' बॉक्स पर सही का निशान नहीं लगा है और जारी रखें पर क्लिक करें.
कंप्यूट और प्राइसिंग में, चुने गए क्षेत्र को वैसे ही रहने दें और n1-standard-4 को अपने मशीन टाइप के तौर पर चुनें:
इस डेमो में दिया गया मॉडल तेज़ी से ट्रेनिंग लेता है. इसलिए, हम छोटे साइज़ की मशीन का इस्तेमाल कर रहे हैं.
अनुमान कंटेनर चरण में, कोई अनुमान कंटेनर नहीं चुनें:
6. मॉडल एंडपॉइंट को डिप्लॉय करना
इस चरण में, हम अपने प्रशिक्षित मॉडल के लिए एक एंडपॉइंट बनाएंगे. हम इसका इस्तेमाल, Vertex AI API की मदद से अपने मॉडल के लिए अनुमान लगाने के लिए कर सकते हैं. ऐसा करने के लिए, हमने एक्सपोर्ट की गई ट्रेन की गई मॉडल ऐसेट का एक वर्शन बनाया है, जो सार्वजनिक GCS बकेट में उपलब्ध है.
किसी संगठन में, मॉडल बनाने के लिए एक टीम या व्यक्ति का प्रभारी होना सामान्य बात है और उसे डिप्लॉय करने का काम कोई और टीम कर सकती है. यहां दिए गए तरीके की मदद से, ट्रेन किए जा चुके मॉडल को इस्तेमाल करने और उसे अनुमान लगाने के लिए डिप्लॉय किया जा सकता है.
यहां हम Vertex AI SDK की मदद से, मॉडल बनाने, उसे एंडपॉइंट पर डिप्लॉय करने, और अनुमान लगाने की जानकारी देंगे.
पहला चरण: Vertex SDK टूल इंस्टॉल करना
Vertex AI SDK को इंस्टॉल करने के लिए, अपने Cloud Shell टर्मिनल से, यह प्रोसेस करें:
pip3 install google-cloud-aiplatform --upgrade --user
हम इस SDK टूल का इस्तेमाल, Vertex के कई अलग-अलग हिस्सों के साथ इंटरैक्ट करने के लिए कर सकते हैं.
दूसरा चरण: मॉडल बनाना और एंडपॉइंट को डिप्लॉय करना
इसके बाद, हम एक Python फ़ाइल बनाएंगे और SDK टूल का इस्तेमाल करके, मॉडल रिसॉर्स बनाएंगे और उसे एंडपॉइंट पर डिप्लॉय करेंगे. Cloud Shell के फ़ाइल एडिटर में जाकर, फ़ाइल और फिर नई फ़ाइल चुनें:
फ़ाइल को deploy.py नाम दें. इस फ़ाइल को अपने एडिटर में खोलें और नीचे दिया गया कोड कॉपी करें:
from google.cloud import aiplatform
# Create a model resource from public model assets
model = aiplatform.Model.upload(
display_name="mpg-imported",
artifact_uri="gs://io-vertex-codelab/mpg-model/",
serving_container_image_uri="gcr.io/cloud-aiplatform/prediction/tf2-cpu.2-3:latest"
)
# Deploy the above model to an endpoint
endpoint = model.deploy(
machine_type="n1-standard-4"
)
इसके बाद, Cloud Shell में टर्मिनल पर वापस जाएं. cd वापस अपनी रूट डायरेक्ट्री पर जाएं और आपकी बनाई गई इस Python स्क्रिप्ट को चलाएं:
cd ..
python3 deploy.py | tee deploy-output.txt
जैसे-जैसे संसाधन बनाए जा रहे हैं, आपको अपने टर्मिनल में अपडेट लॉग हुए दिखेंगे. इसे चलने में 10 से 15 मिनट लगेंगे. यह पक्का करने के लिए कि यह सही तरीके से काम कर रहा है, Vertex AI में अपने कंसोल के मॉडल सेक्शन पर जाएं:
mgp-Imported पर क्लिक करें. इसके बाद, आपको बनाए जा रहे मॉडल के लिए अपना एंडपॉइंट दिखेगा:
एंडपॉइंट के डिप्लॉयमेंट की प्रोसेस पूरी हो जाने के बाद, Cloud Shell टर्मिनल में आपको इस तरह का लॉग दिखेगा:
Endpoint model deployed. Resource name: projects/your-project-id/locations/us-central1/endpoints/your-endpoint-id
अपने डिप्लॉय किए गए एंडोपिंट के बारे में अनुमान पाने के लिए, अगले चरण में इसका इस्तेमाल किया जा सकता है.
तीसरा चरण: डिप्लॉय किए गए एंडपॉइंट पर अनुमान पाना
अपने क्लाउड शेल एडिटर में, predict.py नाम की नई फ़ाइल बनाएं:
predict.py खोलें और उसमें यह कोड चिपकाएं:
from google.cloud import aiplatform
endpoint = aiplatform.Endpoint(
endpoint_name="ENDPOINT_STRING"
)
# A test example we'll send to our model for prediction
test_mpg = [1.4838871833555929,
1.8659883497083019,
2.234620276849616,
1.0187816540094903,
-2.530890710602246,
-1.6046416850441676,
-0.4651483719733302,
-0.4952254087173721,
0.7746763768735953]
response = endpoint.predict([test_mpg])
print('API response: ', response)
print('Predicted MPG: ', response.predictions[0][0])
इसके बाद, अपने टर्मिनल पर वापस जाएं और अनुमानित फ़ाइल में ENDPOINT_STRING को अपने एंडपॉइंट से बदलने के लिए, यह जानकारी डालें:
ENDPOINT=$(cat deploy-output.txt | sed -nre 's:.*Resource name\: (.*):\1:p' | tail -1)
sed -i "s|ENDPOINT_STRING|$ENDPOINT|g" predict.py
अब predict.py फ़ाइल को चलाकर, डिप्लॉय किए गए हमारे मॉडल एंडपॉइंट से अनुमान लगाया जा सकता है:
python3 predict.py
आपको एपीआई से मिले जवाब के साथ-साथ, हमारे टेस्ट के अनुमान के लिए ईंधन की अनुमानित खपत भी दिखेगी.
🎉 बधाई हो! 🎉
आपने Vertex AI को इस्तेमाल करने का तरीका जान लिया है, ताकि:
- कस्टम कंटेनर में ट्रेनिंग कोड देकर, मॉडल को ट्रेनिंग दें. आपने इस उदाहरण में TensorFlow मॉडल का इस्तेमाल किया है, लेकिन आप कस्टम कंटेनर का इस्तेमाल करके किसी भी फ़्रेमवर्क के साथ बनाए गए मॉडल को ट्रेनिंग दे सकते हैं.
- पहले से बने कंटेनर का इस्तेमाल करके, TensorFlow मॉडल को डिप्लॉय करें. इसे उसी वर्कफ़्लो के हिस्से के तौर पर डिप्लॉय करें जिसका इस्तेमाल आपने ट्रेनिंग के लिए किया था.
- मॉडल एंडपॉइंट बनाएं और अनुमान जनरेट करें.
Vertex AI के अलग-अलग हिस्सों के बारे में ज़्यादा जानने के लिए, यह दस्तावेज़ पढ़ें. अगर आपको पांचवें चरण में शुरू की गई ट्रेनिंग का नतीजा देखना है, तो अपने Vertex कंसोल के ट्रेनिंग सेक्शन पर जाएं.
7. साफ़-सफ़ाई सेवा
डिप्लॉय किए गए एंडपॉइंट को मिटाने के लिए, अपने Vertex कंसोल के एंडपॉइंट सेक्शन पर जाएं और 'मिटाएं' आइकॉन पर क्लिक करें:
अपने Cloud Console में नेविगेशन मेन्यू का इस्तेमाल करके, स्टोरेज बकेट मिटाने के लिए स्टोरेज पर जाएं. इसके बाद, अपनी बकेट चुनें और मिटाएं पर क्लिक करें:
