1. खास जानकारी
इस लैब में, कस्टम कंटेनर में मौजूद कोड का इस्तेमाल करके, TensorFlow मॉडल को ट्रेन करने और उसे इस्तेमाल करने के लिए, Vertex AI का इस्तेमाल किया जाएगा.
यहां मॉडल कोड के लिए TensorFlow का इस्तेमाल किया जा रहा है. हालांकि, इसे किसी दूसरे फ़्रेमवर्क से आसानी से बदला जा सकता है.
आपको ये सब सीखने को मिलेगा
आपको, इनके बारे में जानकारी मिलेगी:
- Vertex Workbench में मॉडल ट्रेनिंग कोड बनाना और उसे कंटेनर में रखना
- Vertex AI पर कस्टम मॉडल ट्रेनिंग का काम सबमिट करना
- ट्रेन किए गए मॉडल को किसी एंडपॉइंट पर डिप्लॉय करें और उस एंडपॉइंट का इस्तेमाल करके अनुमान पाएं
इस लैब को Google Cloud पर चलाने की कुल लागत करीब 1 डॉलर है.
2. Vertex AI के बारे में जानकारी
इस लैब में, Google Cloud पर उपलब्ध एआई प्रॉडक्ट की नई सुविधा का इस्तेमाल किया जाता है. Vertex AI, Google Cloud के सभी एमएल प्रॉडक्ट को एक साथ इंटिग्रेट करता है, ताकि डेवलपर को बेहतर अनुभव मिल सके. पहले, AutoML और कस्टम मॉडल से ट्रेन किए गए मॉडल को अलग-अलग सेवाओं के ज़रिए ऐक्सेस किया जा सकता था. नए ऑफ़र में, इन दोनों को एक ही एपीआई में शामिल किया गया है. साथ ही, इसमें अन्य नए प्रॉडक्ट भी शामिल हैं. मौजूदा प्रोजेक्ट को भी Vertex AI पर माइग्रेट किया जा सकता है. अगर आपको कोई सुझाव देना है या शिकायत करनी है, तो कृपया सहायता पेज पर जाएं.
Vertex AI में कई अलग-अलग प्रॉडक्ट शामिल हैं, ताकि मशीन लर्निंग के वर्कफ़्लो को शुरू से लेकर आखिर तक सपोर्ट किया जा सके. इस लैब में, नीचे हाइलाइट किए गए प्रॉडक्ट पर फ़ोकस किया जाएगा: ट्रेनिंग, अनुमान, और वर्कबेंच.
3. अपना एनवायरमेंट सेट अप करना
इस कोडलैब को चलाने के लिए, आपके पास बिलिंग की सुविधा वाला Google Cloud Platform प्रोजेक्ट होना चाहिए. प्रोजेक्ट बनाने के लिए, यहां दिए गए निर्देशों का पालन करें.
पहला चरण: Compute Engine API चालू करना
Compute Engine पर जाएं. अगर यह पहले से चालू नहीं है, तो चालू करें को चुनें. आपको नोटबुक इंस्टेंस बनाने के लिए इसकी ज़रूरत होगी.
दूसरा चरण: Vertex AI API चालू करना
Cloud Console के Vertex AI सेक्शन पर जाएं और Vertex AI API चालू करें पर क्लिक करें.
तीसरा चरण: Container Registry API चालू करना
Container Registry पर जाएं. अगर यह पहले से चालू नहीं है, तो चालू करें को चुनें. इसका इस्तेमाल, कस्टम ट्रेनिंग जॉब के लिए कंटेनर बनाने के लिए किया जाएगा.
चौथा चरण: Vertex AI Workbench इंस्टेंस बनाना
Cloud Console के Vertex AI सेक्शन में जाकर, Workbench पर क्लिक करें:
इसके बाद, उपयोगकर्ता के मैनेज किए गए नोटबुक में जाकर, नई नोटबुक पर क्लिक करें:
इसके बाद, GPU के बिना TensorFlow Enterprise (with LTS) इंस्टेंस टाइप का नया वर्शन चुनें:
डिफ़ॉल्ट विकल्पों का इस्तेमाल करें. इसके बाद, बनाएं पर क्लिक करें.
इस लैब में जिस मॉडल को ट्रेन किया जाएगा और इस्तेमाल किया जाएगा वह TensorFlow के दस्तावेज़ों में दिए गए इस ट्यूटोरियल पर आधारित है. इस ट्यूटोरियल में, किसी वाहन की ईंधन दक्षता का अनुमान लगाने के लिए, Kaggle के Auto MPG डेटासेट का इस्तेमाल किया गया है.
4. ट्रेनिंग कोड को कंटेनर में रखना
हम इस ट्रेनिंग जॉब को Vertex पर सबमिट करेंगे. इसके लिए, हम अपने ट्रेनिंग कोड को Docker कंटेनर में डालेंगे और इस कंटेनर को Google Container Registry पर पुश करेंगे. इस तरीके का इस्तेमाल करके, हम किसी भी फ़्रेमवर्क से बनाए गए मॉडल को ट्रेन कर सकते हैं.
शुरू करने के लिए, लॉन्चर मेन्यू से अपने नोटबुक इंस्टेंस में टर्मिनल विंडो खोलें:
mpg नाम की नई डायरेक्ट्री बनाएं और उसमें cd करें:
mkdir mpg
cd mpg
पहला चरण: Dockerfile बनाना
अपने कोड को कंटेनर में रखने के लिए, सबसे पहले हमें Dockerfile बनाना होगा. हम अपने Dockerfile में, इमेज को चलाने के लिए ज़रूरी सभी कमांड शामिल करेंगे. इससे, इस्तेमाल की जा रही सभी लाइब्रेरी इंस्टॉल हो जाएंगी. साथ ही, ट्रेनिंग कोड के लिए एंट्री पॉइंट सेट अप हो जाएगा. अपने टर्मिनल में, एक खाली Dockerfile बनाएं:
touch Dockerfile
Dockerfile खोलें और इसमें यह कोड कॉपी करें:
FROM gcr.io/deeplearning-platform-release/tf2-cpu.2-6
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 में, Deep Learning Container TensorFlow Enterprise 2.3 Docker इमेज का इस्तेमाल किया गया है. Google Cloud पर मौजूद डीप लर्निंग कंटेनर में, एमएल और डेटा साइंस के कई सामान्य फ़्रेमवर्क पहले से इंस्टॉल होते हैं. हम जिस लाइब्रेरी का इस्तेमाल कर रहे हैं उसमें TF Enterprise 2.3, Pandas, Scikit-learn वगैरह शामिल हैं. उस इमेज को डाउनलोड करने के बाद, यह Dockerfile हमारे ट्रेनिंग कोड के लिए एंट्रीपॉइंट सेट अप करता है. हमने अब तक ये फ़ाइलें नहीं बनाई हैं. अगले चरण में, हम अपने मॉडल को ट्रेनिंग देने और एक्सपोर्ट करने के लिए कोड जोड़ेंगे.
दूसरा चरण: Cloud Storage बकेट बनाना
ट्रेनिंग जॉब में, हम अपने ट्रेन किए गए TensorFlow मॉडल को Cloud Storage बकेट में एक्सपोर्ट करेंगे. Vertex इसका इस्तेमाल, एक्सपोर्ट की गई हमारी मॉडल ऐसेट को पढ़ने और मॉडल को डिप्लॉय करने के लिए करेगा. अपने टर्मिनल से, अपने प्रोजेक्ट के लिए एनवायरमेंट वैरिएबल तय करने के लिए, यहां दिया गया कमांड चलाएं. साथ ही, यह पक्का करें कि आपने your-cloud-project की जगह अपने प्रोजेक्ट का आईडी डाला हो:
PROJECT_ID='your-cloud-project'
इसके बाद, अपने प्रोजेक्ट में नया बकेट बनाने के लिए, अपने टर्मिनल में यह कमांड चलाएं. -l (जगह की जानकारी) फ़्लैग ज़रूरी है, क्योंकि इसे उसी इलाके में सेट करना होगा जहां आपको ट्यूटोरियल में बाद में मॉडल एंडपॉइंट डिप्लॉय करना है:
BUCKET_NAME="gs://${PROJECT_ID}-bucket"
gsutil mb -l us-central1 $BUCKET_NAME
तीसरा चरण: मॉडल ट्रेनिंग कोड जोड़ना
टर्मिनल से, ट्रेनिंग कोड के लिए डायरेक्ट्री बनाने के लिए यह कमांड चलाएं. साथ ही, एक Python फ़ाइल बनाएं, जिसमें हम कोड जोड़ेंगे:
mkdir trainer
touch trainer/train.py
अब आपकी mpg/ डायरेक्ट्री में ये फ़ाइलें होनी चाहिए:
+ Dockerfile
+ trainer/
+ train.py
इसके बाद, अभी बनाई गई train.py फ़ाइल खोलें और यहां दिया गया कोड कॉपी करें. यह कोड, TensorFlow के दस्तावेज़ में दिए गए ट्यूटोरियल से लिया गया है.
फ़ाइल की शुरुआत में, BUCKET वैरिएबल को उस स्टोरेज बकेट के नाम से अपडेट करें जिसे आपने पिछले चरण में बनाया था:
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.
"""
dataset_path = keras.utils.get_file("auto-mpg.data", "http://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data")
dataset_path
"""Import it using pandas"""
column_names = ['MPG','Cylinders','Displacement','Horsepower','Weight',
'Acceleration', 'Model Year', 'Origin']
dataset = pd.read_csv(dataset_path, names=column_names,
na_values = "?", comment='\t',
sep=" ", skipinitialspace=True)
dataset.tail()
# TODO: replace `your-gcs-bucket` with the name of the Storage bucket you created earlier
BUCKET = 'gs://your-gcs-bucket'
"""### 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')
चौथा चरण: कंटेनर को स्थानीय तौर पर बनाना और उसकी जांच करना
अपने टर्मिनल से, Google Container Registry में मौजूद कंटेनर इमेज के यूआरआई के साथ एक वैरिएबल तय करें:
IMAGE_URI="gcr.io/$PROJECT_ID/mpg:v1"
इसके बाद, mpg डायरेक्ट्री के रूट से यह कमांड चलाकर कंटेनर बनाएं:
docker build ./ -t $IMAGE_URI
कंटेनर को अपने नोटबुक इंस्टेंस में चलाएं, ताकि यह पक्का किया जा सके कि वह सही तरीके से काम कर रहा है:
docker run $IMAGE_URI
मॉडल को ट्रेनिंग देने में एक से दो मिनट लगने चाहिए. साथ ही, पुष्टि करने की सटीकता करीब 72% होनी चाहिए. हालांकि, सटीक नतीजे अलग-अलग हो सकते हैं. कंटेनर को स्थानीय तौर पर चलाने के बाद, उसे Google Container Registry पर पुश करें:
docker push $IMAGE_URI
कंटेनर को Container Registry में पुश करने के बाद, अब हम कस्टम मॉडल ट्रेनिंग जॉब शुरू करने के लिए तैयार हैं.
5. Vertex AI पर ट्रेनिंग जॉब चलाना
Vertex AI में, मॉडल को ट्रेन करने के लिए दो विकल्प मिलते हैं:
- AutoML: कम मेहनत और एमएल की विशेषज्ञता के साथ अच्छी क्वालिटी के मॉडल को ट्रेन करें.
- कस्टम ट्रेनिंग: Google Cloud के पहले से बने कंटेनर में से किसी एक का इस्तेमाल करके, क्लाउड में अपने कस्टम ट्रेनिंग ऐप्लिकेशन चलाएं. इसके अलावा, अपने कंटेनर का भी इस्तेमाल किया जा सकता है.
इस लैब में, हम Google Container Registry पर मौजूद अपने कस्टम कंटेनर के ज़रिए कस्टम ट्रेनिंग का इस्तेमाल कर रहे हैं. शुरू करने के लिए, Cloud Console के Vertex सेक्शन में मौजूद मॉडल सेक्शन पर जाएं:
पहला चरण: ट्रेनिंग जॉब शुरू करना
ट्रेनिंग जॉब और डिप्लॉय किए गए मॉडल के पैरामीटर डालने के लिए, बनाएं पर क्लिक करें:
- डेटासेट में जाकर, कोई मैनेज किया गया डेटासेट नहीं चुनें
- इसके बाद, ट्रेनिंग के तरीके के तौर पर कस्टम ट्रेनिंग (ऐडवांस) चुनें और जारी रखें पर क्लिक करें.
- जारी रखें पर क्लिक करें
अगले चरण में, मॉडल का नाम के लिए mpg डालें. इसके अलावा, अपने मॉडल के लिए कोई भी नाम डाला जा सकता है. इसके बाद, कस्टम कंटेनर चुनें:
कंटेनर इमेज टेक्स्ट बॉक्स में, ब्राउज़ करें पर क्लिक करें. इसके बाद, Container Registry में अभी-अभी अपलोड की गई Docker इमेज ढूंढें. बाकी फ़ील्ड को खाली छोड़ दें और जारी रखें पर क्लिक करें.
हम इस ट्यूटोरियल में हाइपरपैरामीटर ट्यूनिंग का इस्तेमाल नहीं करेंगे. इसलिए, 'हाइपरपैरामीटर ट्यूनिंग चालू करें' बॉक्स से सही का निशान हटाएं और जारी रखें पर क्लिक करें.
कंप्यूट और कीमत में, चुने गए क्षेत्र को वैसे ही रहने दें और मशीन टाइप के तौर पर n1-standard-4 चुनें:
ऐक्सलरेटर फ़ील्ड को खाली छोड़ें और जारी रखें को चुनें. इस डेमो में मौजूद मॉडल को कम समय में ट्रेन किया जा सकता है. इसलिए, हम छोटे मशीन टाइप का इस्तेमाल कर रहे हैं.
Prediction container चरण में जाकर, Pre-built container चुनें. इसके बाद, TensorFlow 2.6 चुनें.
पहले से बनाए गए कंटेनर की डिफ़ॉल्ट सेटिंग में कोई बदलाव न करें. मॉडल डायरेक्ट्री में जाकर, mpg सबडायरेक्ट्री वाला अपना GCS बकेट डालें. यह आपकी मॉडल ट्रेनिंग स्क्रिप्ट में वह पाथ है जहां से ट्रेन किए गए मॉडल को एक्सपोर्ट किया जाता है:
Vertex, आपके मॉडल को डिप्लॉय करते समय इस जगह पर देखेगा. अब आप ट्रेनिंग के लिए तैयार हैं! ट्रेनिंग शुरू करने के लिए, ट्रेनिंग शुरू करें पर क्लिक करें. कंसोल के ट्रेनिंग सेक्शन में, आपको कुछ ऐसा दिखेगा:
6. मॉडल एंडपॉइंट डिप्लॉय करना
ट्रेनिंग जॉब सेट अप करते समय, हमने यह तय किया था कि Vertex AI को एक्सपोर्ट की गई हमारी मॉडल ऐसेट कहां ढूंढनी चाहिए. ट्रेनिंग पाइपलाइन के तहत, Vertex इस ऐसेट पाथ के आधार पर एक मॉडल संसाधन बनाएगा. मॉडल रिसोर्स, डिप्लॉय किया गया मॉडल नहीं होता. हालांकि, मॉडल तैयार होने के बाद, उसे किसी एंडपॉइंट पर डिप्लॉय किया जा सकता है. Vertex AI में मॉडल और एंडपॉइंट के बारे में ज़्यादा जानने के लिए, दस्तावेज़ देखें.
इस चरण में, हम अपने ट्रेन किए गए मॉडल के लिए एक एंडपॉइंट बनाएंगे. हम इसका इस्तेमाल, Vertex AI API के ज़रिए अपने मॉडल पर अनुमान पाने के लिए कर सकते हैं.
पहला चरण: एंडपॉइंट डिप्लॉय करना
ट्रेनिंग का काम पूरा होने पर, आपको अपनी कंसोल के मॉडल सेक्शन में mpg नाम का मॉडल दिखेगा. हालांकि, आपने जो भी नाम दिया होगा वह दिखेगा:
ट्रेनिंग का काम पूरा होने पर, Vertex ने आपके लिए एक मॉडल संसाधन बनाया. इस मॉडल का इस्तेमाल करने के लिए, आपको एक एंडपॉइंट डिप्लॉय करना होगा. हर मॉडल के लिए कई एंडपॉइंट हो सकते हैं. मॉडल पर क्लिक करें. इसके बाद, Deploy to endpoint पर क्लिक करें.
नया एंडपॉइंट बनाएं को चुनें और इसे कोई नाम दें. जैसे, v1. ऐक्सेस के लिए, स्टैंडर्ड को चुना हुआ रहने दें. इसके बाद, जारी रखें पर क्लिक करें.
ट्रैफ़िक स्प्लिट को 100 पर सेट रहने दें और कम से कम कंप्यूट नोड की संख्या के लिए 1 डालें. मशीन टाइप में जाकर, n1-standard-2 चुनें. इसके अलावा, अपनी पसंद का कोई भी मशीन टाइप चुना जा सकता है. बाकी डिफ़ॉल्ट सेटिंग को चुना रहने दें. इसके बाद, जारी रखें पर क्लिक करें. हम इस मॉडल के लिए मॉनिटरिंग की सुविधा चालू नहीं करेंगे. इसलिए, एंडपॉइंट डिप्लॉयमेंट शुरू करने के लिए, डिप्लॉय करें पर क्लिक करें.
एंडपॉइंट को डिप्लॉय होने में 10 से 15 मिनट लगेंगे. डिप्लॉय होने के बाद, आपको एक ईमेल मिलेगा. एंडपॉइंट के डिप्लॉय होने के बाद, आपको यह दिखेगा. इससे पता चलता है कि आपके मॉडल रिसॉर्स में एक एंडपॉइंट डिप्लॉय किया गया है:
दूसरा चरण: डिप्लॉय किए गए मॉडल से अनुमान पाना
हम Vertex Python API का इस्तेमाल करके, Python नोटबुक से अपने ट्रेन किए गए मॉडल के बारे में अनुमान लगाएंगे. अपने नोटबुक इंस्टेंस पर वापस जाएं और लॉन्चर से Python 3 नोटबुक बनाएं:
Vertex AI SDK इंस्टॉल करने के लिए, अपनी नोटबुक में किसी सेल में यह कोड चलाएं:
!pip3 install google-cloud-aiplatform --upgrade --user
इसके बाद, एसडीके इंपोर्ट करने के लिए अपनी नोटबुक में एक सेल जोड़ें. साथ ही, अभी-अभी डिप्लॉय किए गए एंडपॉइंट का रेफ़रंस बनाएं:
from google.cloud import aiplatform
endpoint = aiplatform.Endpoint(
endpoint_name="projects/YOUR-PROJECT-NUMBER/locations/us-central1/endpoints/YOUR-ENDPOINT-ID"
)
आपको ऊपर दी गई endpoint_name स्ट्रिंग में मौजूद दो वैल्यू को अपने प्रोजेक्ट नंबर और एंडपॉइंट से बदलना होगा. प्रोजेक्ट नंबर देखने के लिए, प्रोजेक्ट के डैशबोर्ड पर जाएं और प्रोजेक्ट नंबर की वैल्यू देखें.
आपको कंसोल के एंडपॉइंट सेक्शन में अपना एंडपॉइंट आईडी मिल सकता है. इसके लिए, यहां जाएं:
आखिर में, अपने एंडपॉइंट के लिए अनुमान लगाएं. इसके लिए, नीचे दिए गए कोड को कॉपी करें और नई सेल में चलाएं:
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])
इस उदाहरण में पहले से ही सामान्य की गई वैल्यू मौजूद हैं. यह वही फ़ॉर्मैट है जिसकी हमारे मॉडल को ज़रूरत है.
इस सेल को चलाएं. आपको हर गैलन में करीब 16 मील की दूरी तय करने का अनुमान दिखेगा.
🎉 बधाई हो! 🎉
आपने Vertex AI का इस्तेमाल करके ये काम करने का तरीका सीखा है:
- कस्टम कंटेनर में ट्रेनिंग कोड डालकर, मॉडल को ट्रेन करें. इस उदाहरण में, TensorFlow मॉडल का इस्तेमाल किया गया है. हालांकि, कस्टम कंटेनर का इस्तेमाल करके, किसी भी फ़्रेमवर्क से बनाए गए मॉडल को ट्रेन किया जा सकता है.
- ट्रेनिंग के लिए इस्तेमाल किए गए वर्कफ़्लो के तहत, पहले से बने कंटेनर का इस्तेमाल करके TensorFlow मॉडल डिप्लॉय करें.
- मॉडल एंडपॉइंट बनाएं और अनुमान जनरेट करें.
Vertex के अलग-अलग हिस्सों के बारे में ज़्यादा जानने के लिए, दस्तावेज़ देखें.
7. साफ़-सफ़ाई सेवा
अगर आपको इस लैब में बनाई गई नोटबुक का इस्तेमाल जारी रखना है, तो हमारा सुझाव है कि इस्तेमाल न करने पर इसे बंद कर दें. Cloud Console में Workbench के यूज़र इंटरफ़ेस (यूआई) से, नोटबुक को चुनें. इसके बाद, बंद करें को चुनें.
अगर आपको पूरी नोटबुक मिटानी है, तो सबसे ऊपर दाईं ओर मौजूद, 'मिटाएं' बटन पर क्लिक करें.
तैनात किए गए एंडपॉइंट को मिटाने के लिए, Vertex AI कंसोल के एंडपॉइंट सेक्शन पर जाएं. इसके बाद, बनाए गए एंडपॉइंट पर क्लिक करें और एंडपॉइंट से मॉडल को अनडिप्लॉय करें को चुनें:
स्टोरेज बकेट को मिटाने के लिए, Cloud Console में नेविगेशन मेन्यू का इस्तेमाल करके, स्टोरेज पर जाएं. इसके बाद, अपनी बकेट चुनें और मिटाएं पर क्लिक करें:
