1. खास जानकारी
इस लैब में, आपको डेटा एक्सप्लोर करने और एमएल मॉडल को ट्रेनिंग देने के लिए, Vertex AI Workbench का इस्तेमाल करने का तरीका बताया जाएगा.
आपको ये सब सीखने को मिलेगा
आपको, इनके बारे में जानकारी मिलेगी:
- Vertex AI Workbench इंस्टेंस बनाना और उसे कॉन्फ़िगर करना
- Vertex AI Workbench BigQuery कनेक्टर का इस्तेमाल करना
- Vertex AI Workbench कर्नल पर मॉडल को ट्रेन करना
इस लैब को Google Cloud पर चलाने की कुल लागत करीब 1 डॉलर है.
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 में इस डेटासेट को एक्सप्लोर करें. इसके बाद, pandas का इस्तेमाल करके डेटा को 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 सेक्शन में जाकर, Workbench पर क्लिक करें:
अगर Notebooks API पहले से चालू नहीं है, तो इसे चालू करें.
चालू होने के बाद, मैनेज की गई नोटबुक पर क्लिक करें:
इसके बाद, नई नोटबुक चुनें.
अपनी नोटबुक को कोई नाम दें. इसके बाद, अनुमति में जाकर सेवा खाता चुनें
ऐडवांस सेटिंग को चुनें.
अगर सुरक्षा में जाकर "टर्मिनल चालू करें" विकल्प पहले से चालू नहीं है, तो इसे चालू करें.
अन्य सभी ऐडवांस सेटिंग को डिफ़ॉल्ट रूप से सेट रहने दें.
इसके बाद, बनाएं पर क्लिक करें.
इंस्टेंस बन जाने के बाद, JUPYTERLAB खोलें को चुनें.
5. BigQuery में डेटासेट एक्सप्लोर करना
Vertex AI Workbench इंस्टेंस में, बाईं ओर जाएं और BigQuery in Notebooks कनेक्टर पर क्लिक करें.
BigQuery कनेक्टर की मदद से, BigQuery डेटासेट को आसानी से एक्सप्लोर किया जा सकता है और उन पर क्वेरी की जा सकती है. अपने प्रोजेक्ट के डेटासेट के अलावा, प्रोजेक्ट जोड़ें बटन पर क्लिक करके, अन्य प्रोजेक्ट के डेटासेट एक्सप्लोर किए जा सकते हैं.
इस लैब के लिए, BigQuery के सार्वजनिक डेटासेट से मिले डेटा का इस्तेमाल किया जाएगा. नीचे की ओर तब तक स्क्रोल करें, जब तक आपको london_bicycles डेटासेट नहीं मिल जाता. आपको दिखेगा कि इस डेटासेट में दो टेबल हैं: cycle_hire और cycle_stations. आइए, इनमें से हर एक के बारे में जानें.
सबसे पहले, cycle_hire टेबल पर दो बार क्लिक करें. आपको दिखेगा कि टेबल, नए टैब में खुल गई है. इसमें टेबल का स्कीमा और मेटाडेटा भी मौजूद है. जैसे, लाइनों की संख्या और साइज़.
झलक देखें टैब पर क्लिक करने से, आपको डेटा का सैंपल दिखेगा. आइए, एक सामान्य क्वेरी चलाकर देखें कि सबसे ज़्यादा लोकप्रिय यात्राएं कौनसी हैं. सबसे पहले, क्वेरी टेबल बटन पर क्लिक करें.
इसके बाद, SQL एडिटर में यह क्वेरी चिपकाएं और क्वेरी सबमिट करें पर क्लिक करें.
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 फ़ंक्शन का इस्तेमाल करके, दो पॉइंट के बीच की सीधी दूरी को मीटर में कैलकुलेट किया जाएगा. इस वैल्यू का इस्तेमाल, हर साइकल यात्रा में तय की गई दूरी के प्रॉक्सी के तौर पर किया जाएगा.
नीचे दी गई क्वेरी को अपने एसक्यूएल एडिटर में कॉपी करें. इसके बाद, क्वेरी सबमिट करें पर क्लिक करें. ध्यान दें कि JOIN की शर्त में तीन टेबल हैं, क्योंकि हमें साइकिल के शुरुआती स्टेशन और आखिरी स्टेशन, दोनों के अक्षांश/देशांतर की जानकारी पाने के लिए, stations टेबल को दो बार JOIN करना होगा.
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 के लिए कोड कॉपी करें पर क्लिक करें. इससे आपको BigQuery क्लाइंट से कनेक्ट होने वाले नोटबुक में Python कोड चिपकाने की अनुमति मिलेगी. साथ ही, यह डेटा को 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 Functional API का इस्तेमाल करके, TensorFlow मॉडल बनाना होगा. इनपुट डेटा को पहले से प्रोसेस करने के लिए, Keras प्रीप्रोसेसिंग लेयर एपीआई का इस्तेमाल किया जाएगा.
यहां दिया गया यूटिलिटी फ़ंक्शन, 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 लेयर: यह पूर्णांक वाली कैटगरी की वैल्यू को पूर्णांक इंडेक्स में बदलती है.
- CategoryEncoding लेयर: यह पूर्णांक कैटगरी वाली सुविधाओं को वन-हॉट, मल्टी-हॉट या 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)
GPU की मदद से मॉडल को ट्रेन करना
इसके बाद, मॉडल को ज़्यादा समय तक ट्रेन किया जाएगा. साथ ही, ट्रेनिंग की प्रोसेस को तेज़ करने के लिए, हार्डवेयर स्विचर का इस्तेमाल किया जाएगा. 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 की प्रीप्रोसेसिंग लेयर और GPU की मदद से, TensorFlow मॉडल को ट्रेन करना
Vertex AI के अलग-अलग हिस्सों के बारे में ज़्यादा जानने के लिए, दस्तावेज़ देखें.
7. साफ़-सफ़ाई सेवा
हमने नोटबुक को 60 मिनट तक इस्तेमाल न किए जाने पर टाइम आउट होने के लिए कॉन्फ़िगर किया है. इसलिए, हमें इंस्टेंस को बंद करने की ज़रूरत नहीं है. अगर आपको इंस्टेंस को मैन्युअल तरीके से बंद करना है, तो कंसोल के Vertex AI Workbench सेक्शन में जाकर, Stop बटन पर क्लिक करें. अगर आपको नोटबुक पूरी तरह से मिटानी है, तो 'मिटाएं' बटन पर क्लिक करें.
