1. खास जानकारी
यह लैब, AI Platform Notebooks में मौजूद उन अलग-अलग टूल के बारे में जानकारी देगी जिनसे आपको अपना डेटा एक्सप्लोर करने और एमएल मॉडल का प्रोटोटाइप बनाने में मदद मिलेगी.
आपने क्या सीखा
आपको, इनके बारे में जानकारी मिलेगी:
- AI Platform Notebooks इंस्टेंस बनाना और उसे पसंद के मुताबिक बनाना
- AI Platform Notebooks में सीधे तौर पर इंटिग्रेट किए गए गिट की मदद से, अपने नोटबुक कोड को ट्रैक करें
- अपनी नोटबुक में 'क्या होता है' टूल का इस्तेमाल करें
Google Cloud पर इस लैब को चलाने की कुल लागत करीब $1 है. AI Platform Notebooks की कीमतों के बारे में पूरी जानकारी यहां देखी जा सकती है.
2. AI Platform Notebooks इंस्टेंस बनाना
इस कोडलैब को चलाने के लिए, आपके पास Google Cloud Platform का ऐसा प्रोजेक्ट होना चाहिए जिसमें बिलिंग की सुविधा चालू हो. प्रोजेक्ट बनाने के लिए, यहां दिए गए निर्देशों का पालन करें.
दूसरा चरण: Compute Engine API चालू करना
Compute Engine पर जाएं और अगर यह पहले से चालू नहीं है, तो चालू करें को चुनें. आपको अपना notebook इंस्टेंस बनाने के लिए इसकी ज़रूरत होगी.
तीसरा चरण: नोटबुक इंस्टेंस बनाना
अपने Cloud Console के AI Platform Notebooks सेक्शन पर जाएं और नया इंस्टेंस पर क्लिक करें. इसके बाद, बिना जीपीयू के नया TensorFlow 2 Enterprise इंस्टेंस टाइप चुनें:
अपने इंस्टेंस को कोई नाम दें या डिफ़ॉल्ट वैल्यू का इस्तेमाल करें. इसके बाद, हम कस्टमाइज़ेशन के विकल्पों के बारे में जानेंगे. कस्टमाइज़ करें बटन पर क्लिक करें:
AI Platform Notebooks में पसंद के मुताबिक कई तरह के विकल्प मौजूद हैं. जैसे: आपका इंस्टेंस किस क्षेत्र में डिप्लॉय किया गया है, इमेज का टाइप, मशीन का साइज़, जीपीयू की संख्या वगैरह. हम क्षेत्र और पर्यावरण के लिए डिफ़ॉल्ट सेटिंग का इस्तेमाल करेंगे. मशीन कॉन्फ़िगरेशन के लिए, हम n1-standard-8 मशीन का इस्तेमाल करेंगे:
हम कोई जीपीयू नहीं जोड़ेंगे. साथ ही, हम बूट डिस्क, नेटवर्किंग, और अनुमति की डिफ़ॉल्ट सेटिंग का इस्तेमाल करेंगे. अपना इंस्टेंस बनाने के लिए, बनाएं को चुनें. इस प्रोसेस को पूरा होने में कुछ मिनट लगेंगे.
इंस्टेंस बनाने के बाद, आपको Notebooks के यूज़र इंटरफ़ेस (यूआई) में इसके बगल में हरे रंग का सही का निशान दिखेगा. अपना इंस्टेंस खोलने और प्रोटोटाइप करने के लिए, JupyterLab खोलें को चुनें:
इंस्टेंस खोलने पर, कोडलैब नाम की एक नई डायरेक्ट्री बनाएं. इस डायरेक्ट्री में, हम इस पूरे लैब में काम करेंगे:
अपनी नई बनाई गई codelab डायरेक्ट्री पर दो बार क्लिक करके उस पर क्लिक करें. इसके बाद, लॉन्चर से Python 3 notebook चुनें:
नोटबुक का नाम बदलकर demo.ipynb करें या आप इसे कोई भी ऐसा नाम दें जिसे आपको देना है.
चौथा चरण: Python पैकेज इंपोर्ट करना
नोटबुक में एक नया सेल बनाएं और उन लाइब्रेरी को इंपोर्ट करें जिनका इस्तेमाल हम इस कोडलैब में करेंगे:
import pandas as pd
import tensorflow as tf
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
import numpy as np
import json
from sklearn.model_selection import train_test_split
from sklearn.utils import shuffle
from google.cloud import bigquery
from witwidget.notebook.visualization import WitWidget, WitConfigBuilder
3. BigQuery डेटा को अपनी नोटबुक से कनेक्ट करना
Google Cloud के बिग डेटा वेयरहाउस, BigQuery ने आपके एक्सप्लोरेशन के लिए कई डेटासेट सार्वजनिक तौर पर उपलब्ध कराए हैं. AI Platform Notebook, BigQuery के साथ सीधे तौर पर इंटिग्रेशन की सुविधा देते हैं. इसके लिए, पुष्टि करने की ज़रूरत नहीं होती.
इस लैब के लिए, हम जनसंख्या डेटासेट का इस्तेमाल करेंगे. इसमें 40 साल की समयावधि में, अमेरिका में करीब हर जन्म का डेटा शामिल है. इसमें बच्चे के जन्म का वज़न और उसके माता-पिता की डेमोग्राफ़िक जानकारी शामिल है. बच्चे के जन्म के वज़न का अनुमान लगाने के लिए, हम सुविधाओं के सबसेट का इस्तेमाल करेंगे.
पहला चरण: BigQuery डेटा को हमारी notebook में डाउनलोड करना
हम BigQuery के लिए Python क्लाइंट लाइब्रेरी का इस्तेमाल करेंगे, ताकि डेटा को Pandas DataFrame में डाउनलोड किया जा सके. मूल डेटासेट 21 जीबी का है और इसमें 12.3 करोड़ पंक्तियां हैं. चीज़ों को आसान रखने के लिए, हम डेटासेट में सिर्फ़ 10,000 पंक्तियों का इस्तेमाल करेंगे.
क्वेरी बनाएं और इससे मिले DataFrame की झलक, नीचे दिए गए कोड की मदद से देखें. यहां हमें ओरिजनल डेटासेट से चार सुविधाएं मिल रही हैं. साथ ही, बच्चे के वज़न की जानकारी भी दी जा रही है. इस डेटा के बारे में हमारा मॉडल अनुमान लगाता है. डेटासेट कई साल पुराना है, लेकिन इस मॉडल के लिए हम सिर्फ़ 2000 के बाद के डेटा का इस्तेमाल करेंगे:
query="""
SELECT
weight_pounds,
is_male,
mother_age,
plurality,
gestation_weeks
FROM
publicdata.samples.natality
WHERE year > 2000
LIMIT 10000
"""
df = bigquery.Client().query(query).to_dataframe()
df.head()
हमारे डेटासेट में अंकों वाली सुविधाओं की खास जानकारी पाने के लिए, इसे चलाएं:
df.describe()
यह संख्या वाले हमारे कॉलम के लिए, मीन, स्टैंडर्ड डीविएशन, कम से कम, और अन्य मेट्रिक दिखाता है. आखिर में, अपने बूलियन कॉलम में बच्चे के लिंग के बारे में कुछ डेटा देखते हैं. ऐसा करने के लिए, Pandas value_counts तरीके का इस्तेमाल किया जा सकता है:
df['is_male'].value_counts()
ऐसा लगता है कि डेटासेट में लिंग के हिसाब से 50/50 का अंतर करीब-करीब 50/50 है.
दूसरा चरण: ट्रेनिंग के लिए डेटासेट तैयार करना
हमने डेटासेट को Pandas DataFrame के तौर पर अपनी notebook में डाउनलोड कर लिया है. इसलिए, अब हम कुछ प्री-प्रोसेसिंग कर सकते हैं. साथ ही, उसे ट्रेनिंग और टेस्ट सेट में बांट सकते हैं.
सबसे पहले, डेटासेट से शून्य वैल्यू वाली लाइनें छोड़ें और डेटा को शफ़ल करें:
df = df.dropna()
df = shuffle(df, random_state=2)
इसके बाद, लेबल कॉलम को एक अलग वैरिएबल में एक्सट्रैक्ट करें और सिर्फ़ हमारी सुविधाओं के साथ DataFrame बनाएं. is_male एक बूलियन है, इसलिए हम इसे पूर्णांक में बदल देंगे, ताकि हमारे मॉडल के सभी इनपुट अंकों में हों:
labels = df['weight_pounds']
data = df.drop(columns=['weight_pounds'])
data['is_male'] = data['is_male'].astype(int)
अब data.head() चलाकर हमारे डेटासेट की झलक देखने पर, आपको वे चार सुविधाएं दिखेंगी जिनका इस्तेमाल हम ट्रेनिंग के लिए करेंगे.
4. Git शुरू करें
AI Platform Notebooks का सीधे तौर पर git के साथ इंटिग्रेशन किया जाता है, ताकि आप सीधे अपने notebook एनवायरमेंट में वर्शन कंट्रोल कर सकें. यह सीधे notebook के यूज़र इंटरफ़ेस (यूआई) में या JupyterLab में उपलब्ध टर्मिनल के ज़रिए कोड को कमिट करने में मदद करता है. इस सेक्शन में, हम अपनी notebook में git रिपॉज़िटरी शुरू करेंगे. साथ ही, यूज़र इंटरफ़ेस (यूआई) के ज़रिए पहली बार ऐसा करेंगे.
पहला चरण: git रिपॉज़िटरी को शुरू करना
अपनी कोडलैब डायरेक्ट्री से, Git चुनें. इसके बाद, JupyterLab में सबसे ऊपर मौजूद मेन्यू बार से Init चुनें:
जब आपसे पूछा जाए कि क्या आपको इस डायरेक्ट्री को Git Repo बनाना है, तो हां चुनें. इसके बाद, अपनी फ़ाइलों और कमिट की स्थिति देखने के लिए, साइडबार की बाईं ओर मौजूद Git आइकॉन को चुनें:
दूसरा चरण: पहली बार बदलाव करना
इस यूज़र इंटरफ़ेस (यूआई) में, किसी कमिट में फ़ाइलें जोड़ी जा सकती हैं, फ़ाइल में अंतर देखा जा सकता है (हम उस पर बाद में आएंगे) और अपने बदलावों को सेव कर सकते हैं. आइए, अभी-अभी जोड़ी गई नोटबुक फ़ाइल के इस्तेमाल से शुरुआत करते हैं.
अपनी demo.ipynb नोटबुक फ़ाइल को कमिट के लिए स्टेज करने के लिए, उसके बगल में मौजूद बॉक्स चुनें (.ipynb_checkpoints/ डायरेक्ट्री को अनदेखा किया जा सकता है). टेक्स्ट बॉक्स में कमिट मैसेज डालें और फिर अपने बदलाव लागू करने के लिए सही के निशान पर क्लिक करें:
जब आपसे कहा जाए, तब अपना नाम और ईमेल पता डालें. इसके बाद, पहली बार किए गए बदलाव को देखने के लिए, इतिहास टैब पर वापस जाएं:
ध्यान दें कि इस लैब के पब्लिश होने के बाद से हुए अपडेट की वजह से, हो सकता है कि स्क्रीनशॉट आपके यूज़र इंटरफ़ेस (यूआई) से पूरी तरह मेल न खाएं.
5. TensorFlow का मॉडल बनाएं और उसे ट्रेनिंग दें
बच्चे के वज़न का अनुमान लगाने वाला मॉडल बनाने के लिए, हम अपनी नोटबुक में डाउनलोड किए गए BigQuery के नेटवर्क से जुड़े डेटासेट का इस्तेमाल करेंगे. इस लैब में, हम मॉडल की सटीक जानकारी के बजाय, नोटबुक टूलिंग पर ध्यान देंगे.
पहला चरण: अपने डेटा को ट्रेन और टेस्ट सेट में बांटें
अपना मॉडल बनाने से पहले, हम अपने डेटा को बांटने के लिए Scikit Learn train_test_split यूटिलिटी का इस्तेमाल करेंगे:
x,y = data,labels
x_train,x_test,y_train,y_test = train_test_split(x,y)
अब हम TensorFlow का मॉडल बनाने के लिए तैयार हैं!
दूसरा चरण: TensorFlow के मॉडल को बनाना और उसे ट्रेनिंग देना
हम tf.keras Sequential मॉडल एपीआई का इस्तेमाल करके यह मॉडल बनाएंगे. इससे हमें अपने मॉडल को लेयर के स्टैक के तौर पर बताने की सुविधा मिलती है. अपना मॉडल बनाने के लिए हमें सारे कोड की ज़रूरत है:
model = Sequential([
Dense(64, activation='relu', input_shape=(len(x_train.iloc[0]),)),
Dense(32, activation='relu'),
Dense(1)]
)
इसके बाद, हम अपने मॉडल को कंपाइल करेंगे, ताकि हम उसे ट्रेनिंग दे सकें. यहां हम मॉडल के ऑप्टिमाइज़र, लॉस फ़ंक्शन, और मेट्रिक को चुनेंगे, जिन्हें हम ट्रेनिंग के दौरान लॉग करना चाहते हैं. यह एक रिग्रेशन मॉडल है (संख्या वाली वैल्यू का अनुमान लगाते हुए), हम अपनी मेट्रिक के तौर पर सटीक होने के बजाय, मीन स्क्वेयर वाली गड़बड़ी का इस्तेमाल कर रहे हैं:
model.compile(optimizer=tf.keras.optimizers.RMSprop(),
loss=tf.keras.losses.MeanSquaredError(),
metrics=['mae', 'mse'])
हर लेयर पर अपने मॉडल के ट्रेनिंग लायक पैरामीटर की संख्या और आकार देखने के लिए, Keras के आसान model.summary() फ़ंक्शन का इस्तेमाल किया जा सकता है.
अब हम अपने मॉडल को ट्रेनिंग देने के लिए तैयार हैं. हमें सिर्फ़ fit() तरीके को कॉल करना है. इसके बाद, उसे अपना ट्रेनिंग डेटा और लेबल पास करना होगा. यहां हम वैकल्पिक verification_split पैरामीटर का इस्तेमाल करेंगे. यह पैरामीटर, हर चरण पर मॉडल की पुष्टि करने के लिए, ट्रेनिंग डेटा का कुछ हिस्सा सेव करेगा. आम तौर पर, आपको ट्रेनिंग और वैलिडेशन लॉस दोनों में कमी देखनी चाहिए. हालांकि, याद रखें कि इस उदाहरण में हमने मॉडल की क्वालिटी के बजाय, मॉडल और नोटबुक टूलिंग पर ज़्यादा फ़ोकस किया है:
model.fit(x_train, y_train, epochs=10, validation_split=0.1)
तीसरा चरण: जांच के उदाहरणों के लिए अनुमान जनरेट करना
यह देखने के लिए कि हमारा मॉडल कैसा परफ़ॉर्म कर रहा है, आइए हमारे टेस्ट डेटासेट से पहले 10 उदाहरणों पर, टेस्ट के लिए कुछ सुझाव जनरेट करते हैं.
num_examples = 10
predictions = model.predict(x_test[:num_examples])
इसके बाद, हम अपने मॉडल के अनुमानों को फिर से देखेंगे और उनकी असली वैल्यू से तुलना करेंगे:
for i in range(num_examples):
print('Predicted val: ', predictions[i][0])
print('Actual val: ',y_test.iloc[i])
print()
चौथा चरण: git diff का इस्तेमाल करें और बदलाव करें
आपने नोटबुक में कुछ बदलाव किए हैं, इसलिए अब Notebooks के git यूज़र इंटरफ़ेस (यूआई) में उपलब्ध git diff सुविधा का इस्तेमाल करें. demo.ipynb नोटबुक अब "बदला गया" के तहत होनी चाहिए सेक्शन पर जाएं. फ़ाइल नाम पर माउस घुमाएं और डिफ़रेंस आइकॉन पर क्लिक करें:
उसके साथ आपको अपने बदलावों का एक अंतर दिखाई देगा, जैसे नीचे दिया गया है:
इस बार हम कमांड लाइन के ज़रिए Terminal का इस्तेमाल करके, अपने बदलाव करेंगे. JupyterLab के सबसे ऊपर मौजूद मेन्यू बार में Git मेन्यू से, Terminal में Git Command को चुनें. अगर नीचे दिए गए निर्देशों को चलाते समय आपके बाएं साइडबार का git टैब खुला रहता है, तो आपको अपने बदलाव git यूज़र इंटरफ़ेस (यूआई) में दिखेंगे.
अपने नए टर्मिनल इंस्टेंस में, कमिट के लिए अपनी notebook फ़ाइल को स्टेज करने के लिए यह चलाएं:
git add demo.ipynb
और फिर अपने बदलाव करने के लिए ये काम करें (आप अपनी पसंद के किसी भी तय मैसेज का इस्तेमाल कर सकते हैं):
git commit -m "Build and train TF model"
इसके बाद, आपको इतिहास में हाल ही में की गई अपनी प्रतिबद्धता दिखेगी:
6. अपनी नोटबुक से 'क्या-क्या होता है' टूल का इस्तेमाल सीधे तौर पर करें
'What-If टूल' एक इंटरैक्टिव विज़ुअल इंटरफ़ेस है, जिसे आपके डेटासेट को विज़ुअलाइज़ करने और अपने एमएल मॉडल के आउटपुट को बेहतर तरीके से समझने में मदद करने के लिए डिज़ाइन किया गया है. यह एक ओपन सोर्स टूल है, जिसे Google में PAIR टीम ने बनाया है. यह किसी भी मॉडल के साथ काम करता है, लेकिन इसमें कुछ ऐसी सुविधाएं हैं जिन्हें खास तौर पर Cloud AI Platform के लिए बनाया गया है.
'What-If टूल', TensorFlow के साथ Cloud AI Platform Notebooks के इंस्टेंस में पहले से इंस्टॉल होता है. यहां हम इसका इस्तेमाल करके यह देखेंगे कि हमारा मॉडल कैसा परफ़ॉर्म कर रहा है. साथ ही, हम अपने टेस्ट सेट के डेटा पॉइंट पर इसके व्यवहार की जांच करेंगे.
पहला चरण: 'क्या होगा-अगर' टूल के लिए डेटा तैयार करना
व्हाट-इफ़ टूल का ज़्यादा से ज़्यादा फ़ायदा लेने के लिए, हम इसे अपने टेस्ट सेट से उदाहरण भेजेंगे और साथ ही उन उदाहरणों के लिए ज़मीनी सच्चाई वाले लेबल भेजेंगे (y_test). इस तरह हम यह तुलना कर सकते हैं कि हमारे मॉडल ने ज़मीनी हकीकत के बारे में क्या अनुमान लगाया था. हमारे टेस्ट के उदाहरणों और उनके लेबल का इस्तेमाल करके, नया DataFrame बनाने के लिए, नीचे दिए गए कोड की लाइन का इस्तेमाल करें:
wit_data = pd.concat([x_test, y_test], axis=1)
इस लैब में, हम व्हाट-इफ़ टूल को उस मॉडल से कनेक्ट करेंगे जिसे हमने अभी-अभी अपनी नोटबुक में ट्रेनिंग दी है. ऐसा करने के लिए, हमें एक ऐसा फ़ंक्शन लिखना होगा जिसका इस्तेमाल टूल, हमारे मॉडल पर इन टेस्ट डेटा पॉइंट को चलाने के लिए करेगा:
def custom_predict(examples_to_infer):
preds = model.predict(examples_to_infer)
return preds
दूसरा चरण: 'क्या होगा-अगर' टूल को इंस्टैंशिएट करना
हम क्या होगा अगर टूल को इंस्टैंशिएट करेंगे, तो हम अभी बनाए गए टेस्ट डेटासेट और ज़मीनी हकीकत के 500 उदाहरण पास करेंगे. हम इस टूल को सेट अप करने के लिए, अपने डेटा को पास करते हुए, ऊपर बताए गए कस्टम अनुमानित फ़ंक्शन, और टारगेट (जिस चीज़ का अनुमान लगा रहे हैं) के साथ-साथ, मॉडल टाइप, और टूल को सेट अप करने के लिए WitConfigBuilder का एक इंस्टेंस बनाते हैं:
config_builder = (WitConfigBuilder(wit_data[:500].values.tolist(), data.columns.tolist() + ['weight_pounds'])
.set_custom_predict_fn(custom_predict)
.set_target_feature('weight_pounds')
.set_model_type('regression'))
WitWidget(config_builder, height=800)
व्हाट-इफ़ टूल लोड होने पर, आपको कुछ ऐसा दिखना चाहिए:
x-ऐक्सिस पर, मॉडल के अनुमानित वज़न की वैल्यू weight_pounds के हिसाब से अपने टेस्ट डेटा पॉइंट देखे जा सकते हैं.
तीसरा चरण: 'क्या-क्या करें' टूल की मदद से मॉडल के व्यवहार को एक्सप्लोर करना
'क्या होगा अगर' टूल की मदद से आप बहुत सी मज़ेदार चीज़ें कर सकते हैं. हम उनमें से सिर्फ़ कुछ के बारे में यहां बात करेंगे. सबसे पहले, डेटापॉइंट एडिटर के बारे में जानते हैं. किसी भी डेटा पॉइंट को चुनकर, उसकी सुविधाएं देखी जा सकती हैं. साथ ही, उसकी वैल्यू बदली जा सकती हैं. किसी भी डेटा पॉइंट पर क्लिक करके शुरू करें:
बाईं ओर, आपको अपने चुने गए डेटा पॉइंट के लिए सुविधा की वैल्यू दिखेंगी. उस डेटा पॉइंट के ग्राउंड ट्रूथ लेबल की तुलना, मॉडल की अनुमानित वैल्यू से भी की जा सकती है. बाएं साइडबार में, सुविधा की वैल्यू बदल भी जा सकती हैं. साथ ही, मॉडल का अनुमान फिर से चलाकर देखा जा सकता है कि इस बदलाव का आपके मॉडल पर क्या असर पड़ा है. उदाहरण के लिए, हम इस डेटा पॉइंट पर फिर से चलने के अनुमान पर दो बार क्लिक करके, gestation_weeks को 30 में बदल सकते हैं:
'क्या होगा अगर' टूल के प्लॉट सेक्शन में मौजूद ड्रॉपडाउन मेन्यू का इस्तेमाल करके, सभी तरह के कस्टम विज़ुअलाइज़ेशन बनाए जा सकते हैं. उदाहरण के लिए, यहां मॉडल के साथ एक चार्ट दिया गया है x-ऐक्सिस पर वज़न का अनुमान, y-ऐक्सिस पर मां की उम्र, और अनुमान की गड़बड़ी के हिसाब से रंग किए गए पॉइंट. गहरे रंग का मतलब है कि अनुमानित और असल वज़न के बीच का अंतर ज़्यादा है. यहां ऐसा लगता है कि जैसे-जैसे वज़न घटता है, मॉडल की गड़बड़ी थोड़ी बढ़ती है:
इसके बाद, बाईं ओर मौजूद पार्शियल डिपेंडेंसी प्लॉट बटन को चुनें. इससे पता चलता है कि हर सुविधा, मॉडल के अनुमान पर किस तरह असर डालती है. उदाहरण के लिए, गर्भधारण का समय बढ़ने पर, हमारे मॉडल के अनुमान के मुताबिक बच्चे का वज़न भी बढ़ जाता है:
'क्या होगा-अगर' टूल की मदद से ज़्यादा जानकारी पाने के लिए, इस सेक्शन की शुरुआत में दिए गए लिंक पर जाएं.
7. ज़रूरी नहीं: अपने लोकल git रेपो को GitHub से कनेक्ट करें
आखिर में, हम अपनी notebook के इंस्टेंस में git repo को अपने GitHub खाते के रेपो से कनेक्ट करने का तरीका जानेंगे. ऐसा करने के लिए, आपके पास एक GitHub खाता होना चाहिए.
पहला चरण: GitHub पर एक नया रेपो बनाएं
अपने GitHub खाते में, डेटा स्टोर करने की नई जगह बनाएं. इसे नाम और ब्यौरा दें, तय करें कि आपको इसे सार्वजनिक करना है या नहीं. इसके बाद, डेटा स्टोर करने की जगह बनाएं चुनें (आपको README से इसे शुरू करने की ज़रूरत नहीं है). अगले पेज पर, कमांड लाइन से मौजूदा रिपॉज़िटरी को पुश करने के निर्देशों का पालन करें.
Terminal विंडो खोलें और अपनी नई रिपॉज़िटरी को रिमोट के तौर पर जोड़ें. नीचे दिए गए रेपो यूआरएल में username की जगह अपना GitHub उपयोगकर्ता नाम डालें. साथ ही, your-repo को उस उपयोगकर्ता नाम से बदलें जिसे आपने अभी-अभी बनाया है:
git remote add origin git@github.com:username/your-repo.git
दूसरा चरण: अपने notebook के इंस्टेंस में GitHub की पुष्टि करना
इसके बाद, आपको अपने notebook इंस्टेंस से GitHub में पुष्टि करनी होगी. यह प्रोसेस, इस बात पर निर्भर करती है कि आपने GitHub पर दो तरीकों से पुष्टि करने की सुविधा चालू की है या नहीं.
अगर आपको नहीं पता कि कहां से शुरू करना है, तो SSH कुंजी बनाने के लिए, GitHub के दस्तावेज़ में दिया गया तरीका अपनाएं. इसके बाद, GitHub में नई कुंजी जोड़ें.
तीसरा चरण: पक्का करना कि आपने GitHub के रेपो को सही तरीके से लिंक किया हो
यह पक्का करने के लिए कि आपने चीज़ें सही तरीके से सेट अप की हैं, अपने टर्मिनल में git remote -v चलाएं. आपको रिपॉज़िटरी की नई सूची में, रिमोट के तौर पर दिखेगा. GitHub रेपो का यूआरएल देखने और अपनी नोटबुक से GitHub की पुष्टि करने के बाद, अपने notebook इंस्टेंस से सीधे GitHub पर जाएं.
अपने लोकल notebook के git रेपो को नए बनाए गए GitHub रेपो के साथ सिंक करने के लिए, Git साइडबार में सबसे ऊपर मौजूद क्लाउड अपलोड बटन पर क्लिक करें:
GitHub रिपॉज़िटरी को रीफ़्रेश करें. इससे आपको अपने पिछले कमिट वाले notebook कोड दिखेंगे! अगर दूसरे लोगों के पास आपके GitHub रेपो का ऐक्सेस है और आपको अपनी नोटबुक में नए बदलाव देखने हैं, तो उन बदलावों को सिंक करने के लिए क्लाउड डाउनलोड आइकॉन पर क्लिक करें.
Notebooks के गिट यूज़र इंटरफ़ेस (यूआई) के इतिहास टैब पर, यह देखा जा सकता है कि आपके लोकल कमिट को GitHub के साथ सिंक किया गया है या नहीं. इस उदाहरण में, origin/master, GitHub पर हमारे रेपो से मेल खाता है:
जब भी आप नई कमियां करें, तो उन बदलावों को अपने GitHub रेपो में डालने के लिए, बस क्लाउड अपलोड बटन पर फिर से क्लिक करें.
8. बधाई हो!
आपने इस लैब में बहुत कुछ किया है 👏👏👏
आपको याद दिला दें कि आपने ये काम करने का तरीका जाना है:
- AI Platform Notebook के इंस्टेंस को पसंद के मुताबिक बनाना
- उस इंस्टेंस में लोकल git रेपो शुरू करें, git यूज़र इंटरफ़ेस या कमांड लाइन के ज़रिए कमिट जोड़ें, Notebook git यूज़र इंटरफ़ेस (यूआई) में git डिफ़रेंस देखें
- TensorFlow 2 का आसान मॉडल बनाएं और उसे ट्रेनिंग दें
- अपने Notebook इंस्टेंस में 'What-If टूल' का इस्तेमाल करें
- अपने Notebook git repo को GitHub पर किसी बाहरी डेटा स्टोर करने की जगह से कनेक्ट करें
9. साफ़-सफ़ाई सेवा
अगर आपको इस notebook का इस्तेमाल जारी रखना है, तो हमारा सुझाव है कि इस्तेमाल में न होने पर इसे बंद कर दें. अपने Cloud Console में Notebook के यूज़र इंटरफ़ेस (यूआई) से, नोटबुक चुनें और फिर बंद करें चुनें:
यदि आप इस लैब में बनाए गए सभी संसाधनों को हटाना चाहते हैं, तो इसे रोकने के बजाय बस नोटबुक इंस्टेंस को हटाएं.
अपने Cloud Console में नेविगेशन मेन्यू का इस्तेमाल करके, 'स्टोरेज' पर जाएं और अपने मॉडल ऐसेट को स्टोर करने के लिए बनाए गए दोनों बकेट मिटाएं.