1. खास जानकारी
इस लैब में, आपको डेटा एक्सप्लोरेशन और एमएल मॉडल को ट्रेनिंग देने के लिए, Vertex AI Workbench का इस्तेमाल करने का तरीका पता चलेगा.
आपको ये सब सीखने को मिलेगा
आपको, इनके बारे में जानकारी मिलेगी:
- Vertex AI Workbench इंस्टेंस बनाना और उसे कॉन्फ़िगर करना
- Vertex AI Workbench BigQuery कनेक्टर का इस्तेमाल करना
- Vertex AI Workbench के कर्नेल पर मॉडल को ट्रेन करना
Google Cloud पर इस लैब को चलाने की कुल लागत एक डॉलर है.
2. Vertex AI के बारे में जानकारी
यह लैब, Google Cloud पर उपलब्ध एआई प्रॉडक्ट के सबसे नए वर्शन का इस्तेमाल करता है. Vertex AI, Google Cloud के सभी एमएल ऑफ़र को डेवलपमेंट के बेहतर अनुभव के साथ इंटिग्रेट करता है. पहले, AutoML और कस्टम मॉडल की मदद से ट्रेन किए गए मॉडल अलग-अलग सेवाओं से ऐक्सेस किए जा सकते थे. नई सुविधा में, दोनों को एक ही एपीआई में जोड़ा गया है. साथ ही, इसमें अन्य नए प्रॉडक्ट भी शामिल हैं. आपके पास मौजूदा प्रोजेक्ट को Vertex AI पर माइग्रेट करने का विकल्प भी है.
Vertex AI में कई तरह के प्रॉडक्ट शामिल हैं, जो मशीन लर्निंग के वर्कफ़्लो को मैनेज करने में मदद करते हैं. इस लैब में Vertex AI Workbench पर फ़ोकस किया जाएगा.
Vertex AI Workbench, डेटा सेवाओं (जैसे, Dataproc, Dataflow, BigQuery, और Dataplex) और Vertex AI के साथ बेहतर तरीके से इंटिग्रेट होता है. इससे, उपयोगकर्ताओं को नोटबुक पर आधारित एंड-टू-एंड वर्कफ़्लो को तेज़ी से बनाने में मदद मिलती है. इसकी मदद से, डेटा साइंटिस्ट GCP की डेटा सेवाओं से कनेक्ट कर सकते हैं, डेटासेट का विश्लेषण कर सकते हैं, मॉडलिंग की अलग-अलग तकनीकों के साथ प्रयोग कर सकते हैं, ट्रेन किए गए मॉडल को प्रोडक्शन में डिप्लॉय कर सकते हैं, और मॉडल के लाइफ़साइकल के दौरान MLOps को मैनेज कर सकते हैं.
3. इस्तेमाल के उदाहरण की खास जानकारी
इस लैब में, आपको लंदन में साइकल किराये पर लेने से जुड़ा डेटासेट एक्सप्लोर करना होगा. इस डेटा में, 2011 से लंदन के सार्वजनिक साइकल शेयरिंग प्रोग्राम से साइकल की गई यात्राओं की जानकारी शामिल है. Vertex AI Workbench के BigQuery कनेक्टर की मदद से, BigQuery में इस डेटासेट को एक्सप्लोर करना शुरू करें. इसके बाद, पांडा का इस्तेमाल करके Jupyter Notebook में डेटा लोड किया जाएगा. साथ ही, TensorFlow के मॉडल को ट्रेनिंग दी जाएगी, ताकि इस आधार पर साइकल यात्रा में लगने वाले समय का अनुमान लगाया जा सके. यह अनुमान इस आधार पर लगाया जाता है कि व्यक्ति ने कब और कितनी दूर तक साइकल चलाई.
इस लैब में, Keras की प्रीप्रोसेसिंग लेयर का इस्तेमाल करके, मॉडल ट्रेनिंग के लिए इनपुट डेटा को बदला और तैयार किया जाता है. इस एपीआई की मदद से, TensorFlow मॉडल ग्राफ़ में सीधे प्रीप्रोसेसिंग की सुविधा जोड़ी जा सकती है. इससे, ट्रेनिंग/सेवा देने में होने वाली गड़बड़ी का जोखिम कम हो जाता है. ऐसा इसलिए होता है, क्योंकि ट्रेनिंग डेटा और सेवा देने वाले डेटा को एक जैसा बदलाव किया जाता है. ध्यान दें कि TensorFlow 2.6 के बाद, यह एपीआई स्टेबल है. अगर TensorFlow का पुराना वर्शन इस्तेमाल किया जा रहा है, तो आपको एक्सपेरिमेंट के तौर पर उपलब्ध सिंबल को इंपोर्ट करना होगा.
4. अपना एनवायरमेंट सेट अप करना
इस कोडलैब को चलाने के लिए, आपके पास बिलिंग की सुविधा वाला Google Cloud Platform प्रोजेक्ट होना चाहिए. प्रोजेक्ट बनाने के लिए, यहां दिए गए निर्देशों का पालन करें.
पहला चरण: Compute Engine API चालू करना
Compute Engine पर जाएं और अगर यह पहले से चालू नहीं है, तो चालू करें को चुनें.
दूसरा चरण: Vertex AI API को चालू करना
अपने Cloud Console के Vertex AI सेक्शन पर जाएं और Vertex AI API चालू करें पर क्लिक करें.
तीसरा चरण: Vertex AI Workbench इंस्टेंस बनाना
अपने Cloud Console के Vertex AI सेक्शन में, वर्कबेंच पर क्लिक करें:
अगर Notebooks API पहले से चालू नहीं है, तो उसे चालू करें.
चालू करने के बाद, मैनेज की जा रही नोटबुक पर क्लिक करें:
इसके बाद, नई नोटबुक चुनें.
अपनी नोटबुक को कोई नाम दें. इसके बाद, अनुमति में जाकर, सेवा खाता चुनें
ऐडवांस सेटिंग को चुनें.
अगर टर्मिनल की सुविधा पहले से चालू नहीं है, तो सुरक्षा में जाकर, "टर्मिनल चालू करें" को चुनें.
अन्य सभी बेहतर सेटिंग को पहले जैसा ही रहने दें.
इसके बाद, बनाएं पर क्लिक करें.
इंस्टेंस बन जाने के बाद, JUPYTERLAB खोलें को चुनें.
5. BigQuery में डेटासेट एक्सप्लोर करना
Vertex AI Workbench इंस्टेंस में, बाईं ओर जाएं और नोटबुक में BigQuery कनेक्टर पर क्लिक करें.
BigQuery कनेक्टर की मदद से, BigQuery डेटासेट को आसानी से एक्सप्लोर और क्वेरी किया जा सकता है. अपने प्रोजेक्ट के डेटासेट के अलावा, प्रोजेक्ट जोड़ें बटन पर क्लिक करके, दूसरे प्रोजेक्ट के डेटासेट भी एक्सप्लोर किए जा सकते हैं.
इस लैब के लिए, आपको BigQuery के सार्वजनिक डेटासेट के डेटा का इस्तेमाल करना होगा. नीचे की ओर स्क्रोल करके, london_bicycles डेटासेट ढूंढें. आपको दिखेगा कि इस डेटासेट में दो टेबल हैं, cycle_hire और cycle_stations. आइए, इनमें से हर एक के बारे में जानते हैं.
सबसे पहले, cycle_hire टेबल पर दो बार क्लिक करें. आपको टेबल, नए टैब के तौर पर दिखेगी. इसमें टेबल का स्कीमा और मेटाडेटा भी दिखेगा. जैसे, लाइनों की संख्या और साइज़.
झलक देखें टैब पर क्लिक करने पर, आपको डेटा का सैंपल दिखेगा. आइए, एक आसान क्वेरी चलाकर देखें कि कौनसी यात्राएं लोकप्रिय हैं. सबसे पहले, क्वेरी टेबल बटन पर क्लिक करें.
इसके बाद, एसक्यूएल एडिटर में यह क्वेरी चिपकाएं और क्वेरी सबमिट करें पर क्लिक करें.
SELECT
start_station_name,
end_station_name,
IF(start_station_name = end_station_name,
TRUE,
FALSE) same_station,
AVG(duration) AS avg_duration,
COUNT(*) AS total_rides
FROM
`bigquery-public-data.london_bicycles.cycle_hire`
GROUP BY
start_station_name,
end_station_name,
same_station
ORDER BY
total_rides DESC
क्वेरी के नतीजों से आपको पता चलेगा कि हाइड पार्क कॉर्नर स्टेशन से साइकल की सबसे ज़्यादा यात्राएं की गईं.
इसके बाद, cycle_stations टेबल पर दो बार क्लिक करें. इससे आपको हर स्टेशन की जानकारी मिलेगी.
हम cycle_hire और cycle_stations टेबल में शामिल होना चाहते हैं. cycle_stations टेबल में, हर स्टेशन के लिए अक्षांश/देशांतर की जानकारी होती है. इस जानकारी का इस्तेमाल करके, साइकल की हर यात्रा में तय की गई दूरी का अनुमान लगाया जा सकता है. इसके लिए, आपको साइकल की शुरुआत और आखिरी स्टेशन के बीच की दूरी का हिसाब लगाना होगा.
यह हिसाब लगाने के लिए, आपको BigQuery के भौगोलिक फ़ंक्शन इस्तेमाल करने होंगे. खास तौर पर, आपको हर अक्षांश/देशांतर स्ट्रिंग को ST_GEOGPOINT में बदलना होगा. साथ ही, दो पॉइंट के बीच मीटर में सीधी लाइन की दूरी पता करने के लिए, ST_DISTANCE फ़ंक्शन का इस्तेमाल करना होगा. इस वैल्यू का इस्तेमाल, साइकल की हर यात्रा में तय की गई दूरी के प्रॉक्सी के तौर पर किया जाएगा.
नीचे दी गई क्वेरी को अपने एसक्यूएल एडिटर में कॉपी करें. इसके बाद, 'क्वेरी सबमिट करें' पर क्लिक करें. ध्यान दें कि जॉइन कंडीशन में तीन टेबल होती हैं, क्योंकि हमें साइकल के शुरुआती स्टेशन और आखिरी स्टेशन, दोनों का अक्षांश/देशांतर हासिल करने के लिए, स्टेशन टेबल को दो बार जोड़ना होगा.
WITH staging AS (
SELECT
STRUCT(
start_stn.name,
ST_GEOGPOINT(start_stn.longitude, start_stn.latitude) AS POINT,
start_stn.docks_count,
start_stn.install_date
) AS starting,
STRUCT(
end_stn.name,
ST_GEOGPOINT(end_stn.longitude, end_stn.latitude) AS point,
end_stn.docks_count,
end_stn.install_date
) AS ending,
STRUCT(
rental_id,
bike_id,
duration, --seconds
ST_DISTANCE(
ST_GEOGPOINT(start_stn.longitude, start_stn.latitude),
ST_GEOGPOINT(end_stn.longitude, end_stn.latitude)
) AS distance, --meters
start_date,
end_date
) AS bike
FROM `bigquery-public-data.london_bicycles.cycle_stations` AS start_stn
LEFT JOIN `bigquery-public-data.london_bicycles.cycle_hire` as b
ON start_stn.id = b.start_station_id
LEFT JOIN `bigquery-public-data.london_bicycles.cycle_stations` AS end_stn
ON end_stn.id = b.end_station_id
LIMIT 700000)
SELECT * from STAGING
6. TensorFlow के कर्नेल पर किसी एमएल मॉडल को ट्रेन करना
Vertex AI Workbench में, कंप्यूट के साथ काम करने की सुविधा वाली लेयर होती है. इसकी मदद से, एक ही नोटबुक इंस्टेंस से TensorFlow, PySpark, R वगैरह के लिए कर्नेल लॉन्च किए जा सकते हैं. इस लैब में, आप TensorFlow कर्नेल का इस्तेमाल करके एक नोटबुक बनाएंगे.
DataFrame बनाना
क्वेरी लागू होने के बाद, DataFrame के लिए कोड कॉपी करें पर क्लिक करें. इसकी मदद से, Python कोड को ऐसी नोटबुक में चिपकाया जा सकता है जो BigQuery क्लाइंट से कनेक्ट होती है और इस डेटा को pandas DataFrame के तौर पर एक्सट्रैक्ट करती है.
इसके बाद, लॉन्चर पर वापस जाएं और TensorFlow 2 नोटबुक बनाएं.
नोटबुक की पहली सेल में, क्वेरी एडिटर से कॉपी किया गया कोड चिपकाएं. यह इस तरह दिखना चाहिए:
# The following two lines are only necessary to run once.
# Comment out otherwise for speed-up.
from google.cloud.bigquery import Client, QueryJobConfig
client = Client()
query = """WITH staging AS (
SELECT
STRUCT(
start_stn.name,
ST_GEOGPOINT(start_stn.longitude, start_stn.latitude) AS POINT,
start_stn.docks_count,
start_stn.install_date
) AS starting,
STRUCT(
end_stn.name,
ST_GEOGPOINT(end_stn.longitude, end_stn.latitude) AS point,
end_stn.docks_count,
end_stn.install_date
) AS ending,
STRUCT(
rental_id,
bike_id,
duration, --seconds
ST_DISTANCE(
ST_GEOGPOINT(start_stn.longitude, start_stn.latitude),
ST_GEOGPOINT(end_stn.longitude, end_stn.latitude)
) AS distance, --meters
start_date,
end_date
) AS bike
FROM `bigquery-public-data.london_bicycles.cycle_stations` AS start_stn
LEFT JOIN `bigquery-public-data.london_bicycles.cycle_hire` as b
ON start_stn.id = b.start_station_id
LEFT JOIN `bigquery-public-data.london_bicycles.cycle_stations` AS end_stn
ON end_stn.id = b.end_station_id
LIMIT 700000)
SELECT * from STAGING"""
job = client.query(query)
df = job.to_dataframe()
इस लैब के लिए, हमने डेटासेट को 7,00,000 तक सीमित रखा है, ताकि ट्रेनिंग में लगने वाला समय कम हो. हालांकि, क्वेरी में बदलाव करने और पूरे डेटासेट के साथ प्रयोग करने में संकोच न करें.
इसके बाद, ज़रूरी लाइब्रेरी इंपोर्ट करें.
from datetime import datetime
import pandas as pd
import tensorflow as tf
छोटी डेटाफ़्रेम बनाने के लिए, नीचे दिया गया कोड चलाएं. इसमें सिर्फ़ इस एक्सरसाइज़ के एमएल हिस्से के लिए ज़रूरी कॉलम शामिल होंगे.
values = df['bike'].values
duration = list(map(lambda a: a['duration'], values))
distance = list(map(lambda a: a['distance'], values))
dates = list(map(lambda a: a['start_date'], values))
data = pd.DataFrame(data={'duration': duration, 'distance': distance, 'start_date':dates})
data = data.dropna()
start_date कॉलम, Python datetime है. इस datetime का इस्तेमाल सीधे मॉडल में करने के बजाय, आपको दो नई सुविधाएं बनानी होंगी. इनसे यह पता चलेगा कि साइकल की यात्रा किस दिन और किस समय की गई.
data['weekday'] = data['start_date'].apply(lambda a: a.weekday())
data['hour'] = data['start_date'].apply(lambda a: a.time().hour)
data = data.drop(columns=['start_date'])
आखिर में, अवधि वाले कॉलम को सेकंड से मिनट में बदलें, ताकि इसे समझना आसान हो
data['duration'] = data['duration'].apply(lambda x:float(x / 60))
फ़ॉर्मैट किए गए DataFrame की शुरुआती कुछ पंक्तियों की जांच करें. साइकल की हर यात्रा के लिए, अब आपके पास हफ़्ते के दिन और यात्रा के समय का डेटा है. साथ ही, यात्रा की दूरी का डेटा भी है. इस जानकारी से, यह अनुमान लगाया जा सकता है कि यात्रा में कितना समय लगा.
data.head()
मॉडल बनाने और उसे ट्रेन करने से पहले, आपको डेटा को ट्रेनिंग और पुष्टि करने वाले सेट में बांटना होगा.
# Use 80/20 train/eval split
train_size = int(len(data) * .8)
print ("Train size: %d" % train_size)
print ("Evaluation size: %d" % (len(data) - train_size))
# Split data into train and test sets
train_data = data[:train_size]
val_data = data[train_size:]
TensorFlow का मॉडल बनाएं
आपको Keras फ़ंक्शनल एपीआई का इस्तेमाल करके, TensorFlow मॉडल बनाना होगा. इनपुट डेटा को पहले से प्रोसेस करने के लिए, आपको Keras preprocessing layers API का इस्तेमाल करना होगा.
यहां दिया गया यूटिलिटी फ़ंक्शन, pandas Dataframe से tf.data.Dataset बना देगा.
def df_to_dataset(dataframe, label, shuffle=True, batch_size=32):
dataframe = dataframe.copy()
labels = dataframe.pop(label)
ds = tf.data.Dataset.from_tensor_slices((dict(dataframe), labels))
if shuffle:
ds = ds.shuffle(buffer_size=len(dataframe))
ds = ds.batch(batch_size)
ds = ds.prefetch(batch_size)
return ds
ऊपर दिए गए फ़ंक्शन का इस्तेमाल दो tf.data.Dataset बनाने के लिए करें. एक ट्रेनिंग के लिए और दूसरा पुष्टि करने के लिए. आपको कुछ चेतावनियां दिख सकती हैं, लेकिन उन्हें अनदेखा किया जा सकता है.
train_dataset = df_to_dataset(train_data, 'duration')
validation_dataset = df_to_dataset(val_data, 'duration')
आपको मॉडल में, डेटा को प्री-प्रोसेस करने वाली इन लेयर का इस्तेमाल करना होगा:
- नॉर्मलाइज़ेशन लेयर: यह इनपुट सुविधाओं के लिए, सुविधा के हिसाब से नॉर्मलाइज़ेशन की सुविधा देता है.
- IntegerLookup लेयर: यह कैटगरी वाली पूर्णांक वैल्यू को पूर्णांक इंडेक्स में बदल देती है.
- कैटगरी को कोड में बदलने वाली लेयर: यह पूर्णांक वाली कैटगरी वाली फ़ीचर को एक-हॉट, मल्टी-हॉट या TF-IDF डेंस रिप्रज़ेंटेशन में बदल देती है.
ध्यान दें कि इन लेयर को ट्रेन नहीं किया जा सकता. इसके बजाय, adapt() तरीके का इस्तेमाल करके, ट्रेनिंग डेटा को प्रीप्रोसेसिंग लेयर के सामने पेश करके, उसकी स्थिति सेट की जाती है.
यहां दिया गया फ़ंक्शन, नॉर्मलाइज़ेशन लेयर बनाएगा. इसका इस्तेमाल, दूरी की सुविधा पर किया जा सकता है. ट्रेनिंग डेटा पर adapt() तरीके का इस्तेमाल करके, मॉडल को फ़िट करने से पहले स्थिति सेट की जाएगी. इससे, सामान्य बनाने के लिए इस्तेमाल किए जाने वाले औसत और वैरिएंस का हिसाब लगाया जाएगा. बाद में, जब मॉडल को वैलिडेशन डेटासेट पास किया जाएगा, तो ट्रेनिंग डेटा पर कैलकुलेट किए गए इसी माध्य और वैरिएंस का इस्तेमाल, वैलिडेशन डेटा को स्केल करने के लिए किया जाएगा.
def get_normalization_layer(name, dataset):
# Create a Normalization layer for our feature.
normalizer = tf.keras.layers.Normalization(axis=None)
# Prepare a Dataset that only yields our feature.
feature_ds = dataset.map(lambda x, y: x[name])
# Learn the statistics of the data.
normalizer.adapt(feature_ds)
return normalizer
इसी तरह, यह फ़ंक्शन एक कैटगरी कोडिंग बनाता है. इसका इस्तेमाल, घंटे और कामकाजी दिनों की सुविधाओं के लिए किया जाएगा.
def get_category_encoding_layer(name, dataset, dtype, max_tokens=None):
index = tf.keras.layers.IntegerLookup(max_tokens=max_tokens)
# Prepare a Dataset that only yields our feature
feature_ds = dataset.map(lambda x, y: x[name])
# Learn the set of possible values and assign them a fixed integer index.
index.adapt(feature_ds)
# Create a Discretization for our integer indices.
encoder = tf.keras.layers.CategoryEncoding(num_tokens=index.vocabulary_size())
# Apply one-hot encoding to our indices. The lambda function captures the
# layer so we can use them, or include them in the functional model later.
return lambda feature: encoder(index(feature))
इसके बाद, मॉडल का प्रीप्रोसेसिंग वाला हिस्सा बनाएं. सबसे पहले, हर सुविधा के लिए एक tf.keras.Input लेयर बनाएं.
# Create a Keras input layer for each feature
numeric_col = tf.keras.Input(shape=(1,), name='distance')
hour_col = tf.keras.Input(shape=(1,), name='hour', dtype='int64')
weekday_col = tf.keras.Input(shape=(1,), name='weekday', dtype='int64')
इसके बाद, सामान्य बनाने और कैटगरी को कोड में बदलने वाली लेयर बनाएं और उन्हें सूची में सेव करें.
all_inputs = []
encoded_features = []
# Pass 'distance' input to normalization layer
normalization_layer = get_normalization_layer('distance', train_dataset)
encoded_numeric_col = normalization_layer(numeric_col)
all_inputs.append(numeric_col)
encoded_features.append(encoded_numeric_col)
# Pass 'hour' input to category encoding layer
encoding_layer = get_category_encoding_layer('hour', train_dataset, dtype='int64')
encoded_hour_col = encoding_layer(hour_col)
all_inputs.append(hour_col)
encoded_features.append(encoded_hour_col)
# Pass 'weekday' input to category encoding layer
encoding_layer = get_category_encoding_layer('weekday', train_dataset, dtype='int64')
encoded_weekday_col = encoding_layer(weekday_col)
all_inputs.append(weekday_col)
encoded_features.append(encoded_weekday_col)
प्री-प्रोसेसिंग लेयर तय करने के बाद, बाकी मॉडल को तय किया जा सकता है. आपको सभी इनपुट फ़ीचर को जोड़ना होगा और उन्हें डेंस लेयर में भेजना होगा. यह एक रिग्रेशन समस्या है, इसलिए आउटपुट लेयर एक यूनिट है.
all_features = tf.keras.layers.concatenate(encoded_features)
x = tf.keras.layers.Dense(64, activation="relu")(all_features)
output = tf.keras.layers.Dense(1)(x)
model = tf.keras.Model(all_inputs, output)
आखिर में, मॉडल को कंपाइल करें.
model.compile(optimizer = tf.keras.optimizers.Adam(0.001),
loss='mean_squared_logarithmic_error')
मॉडल तय करने के बाद, आर्किटेक्चर को विज़ुअलाइज़ किया जा सकता है
tf.keras.utils.plot_model(model, show_shapes=True, rankdir="LR")
ध्यान दें कि इस आसान डेटासेट के लिए, यह मॉडल काफ़ी जटिल है. इसका मकसद, डेमो के तौर पर दिखाना है.
कोड चल रहा है या नहीं, इसकी पुष्टि करने के लिए एक एपिसोड के लिए ट्रेनिंग दें.
model.fit(train_dataset, validation_data = validation_dataset, epochs = 1)
जीपीयू की मदद से मॉडल को ट्रेन करना
इसके बाद, आपको मॉडल को ज़्यादा समय तक ट्रेनिंग देनी होगी. साथ ही, ट्रेनिंग की प्रोसेस को तेज़ करने के लिए, हार्डवेयर स्विचर का इस्तेमाल करना होगा. Vertex AI Workbench की मदद से, अपने इंस्टेंस को बंद किए बिना हार्डवेयर बदला जा सकता है. ज़रूरत के समय ही जीपीयू जोड़ने से, खर्च कम हो सकता है.
हार्डवेयर प्रोफ़ाइल बदलने के लिए, सबसे ऊपर दाएं कोने में मौजूद मशीन टाइप पर क्लिक करें और हार्डवेयर में बदलाव करें को चुनें
'जीपीयू अटैच करें' चुनें और NVIDIA T4 Tensor Core GPU चुनें.
हार्डवेयर को कॉन्फ़िगर होने में करीब पांच मिनट लगेंगे. प्रोसेस पूरी होने के बाद, मॉडल को थोड़ी देर और ट्रेनिंग दें. आपको पता चलेगा कि अब हर एपिक में कम समय लगता है.
model.fit(train_dataset, validation_data = validation_dataset, epochs = 5)
🎉 बधाई हो! 🎉
आपने Vertex AI Workbench का इस्तेमाल करके, ये काम करने का तरीका जाना है:
- BigQuery में डेटा एक्सप्लोर करना
- Python में डेटा लोड करने के लिए, BigQuery क्लाइंट का इस्तेमाल करना
- Keras की प्री-प्रोसेसिंग लेयर और जीपीयू की मदद से, TensorFlow मॉडल को ट्रेन करना
Vertex AI के अलग-अलग हिस्सों के बारे में ज़्यादा जानने के लिए, यह दस्तावेज़ पढ़ें.
7. साफ़-सफ़ाई सेवा
हमने नोटबुक को 60 मिनट तक कोई गतिविधि न होने पर टाइम आउट होने के लिए कॉन्फ़िगर किया है. इसलिए, हमें इंस्टेंस को बंद करने के बारे में चिंता करने की ज़रूरत नहीं है. अगर आपको इंस्टेंस को मैन्युअल तरीके से बंद करना है, तो कंसोल के Vertex AI Workbench सेक्शन में जाकर, 'बंद करें' बटन पर क्लिक करें. अगर आपको नोटबुक को पूरी तरह से मिटाना है, तो मिटाएं बटन पर क्लिक करें.
