1. खास जानकारी
इस लैब में, आपको AI Platform Notebooks में मौजूद अलग-अलग टूल के बारे में जानकारी मिलेगी. इन टूल का इस्तेमाल करके, डेटा एक्सप्लोर किया जा सकता है और एमएल मॉडल के प्रोटोटाइप बनाए जा सकते हैं.
आपको क्या सीखने को मिलेगा
आपको, इनके बारे में जानकारी मिलेगी:
- AI Platform Notebooks इंस्टेंस बनाना और उसे पसंद के मुताबिक बनाना
- AI Platform Notebooks में सीधे तौर पर इंटिग्रेट किए गए git की मदद से, अपनी नोटबुक के कोड को ट्रैक करें
- अपनी नोटबुक में व्हाट-इफ़ टूल का इस्तेमाल करना
इस लैब को Google Cloud पर चलाने की कुल लागत करीब 1 डॉलर है. AI Platform Notebooks की कीमत के बारे में पूरी जानकारी यहां देखी जा सकती है.
2. AI Platform Notebooks का इंस्टेंस बनाना
इस कोडलैब को चलाने के लिए, आपके पास बिलिंग की सुविधा वाला Google Cloud Platform प्रोजेक्ट होना चाहिए. प्रोजेक्ट बनाने के लिए, यहां दिए गए निर्देशों का पालन करें.
दूसरा चरण: Compute Engine API चालू करना
Compute Engine पर जाएं. अगर यह पहले से चालू नहीं है, तो चालू करें को चुनें. आपको नोटबुक इंस्टेंस बनाने के लिए इसकी ज़रूरत होगी.
तीसरा चरण: नोटबुक इंस्टेंस बनाना
Cloud Console के AI Platform Notebooks सेक्शन पर जाएं और नया इंस्टेंस पर क्लिक करें. इसके बाद, GPU के बिना TensorFlow 2 Enterprise का सबसे नया इंस्टेंस टाइप चुनें:
अपने इंस्टेंस को कोई नाम दें या डिफ़ॉल्ट नाम का इस्तेमाल करें. इसके बाद, हम पसंद के मुताबिक बनाने के विकल्पों के बारे में जानेंगे. कस्टमाइज़ करें बटन पर क्लिक करें:
AI Platform Notebooks में, पसंद के मुताबिक बनाने के कई विकल्प उपलब्ध हैं. जैसे: आपका इंस्टेंस किस इलाके में डिप्लॉय किया गया है, इमेज टाइप, मशीन का साइज़, जीपीयू की संख्या वगैरह. हम क्षेत्र और एनवायरमेंट के लिए डिफ़ॉल्ट सेटिंग का इस्तेमाल करेंगे. मशीन कॉन्फ़िगरेशन के लिए, हम n1-standard-8 मशीन का इस्तेमाल करेंगे:
हम कोई GPU नहीं जोड़ेंगे. साथ ही, बूट डिस्क, नेटवर्किंग, और अनुमति के लिए डिफ़ॉल्ट सेटिंग का इस्तेमाल करेंगे. अपना इंस्टेंस बनाने के लिए, बनाएं को चुनें. इस प्रोसेस को पूरा होने में कुछ मिनट लगेंगे.
इंस्टेंस बन जाने के बाद, आपको Notebooks के यूज़र इंटरफ़ेस (यूआई) में उसके बगल में हरे रंग का सही का निशान दिखेगा. अपना इंस्टेंस खोलने और प्रोटोटाइपिंग शुरू करने के लिए, JupyterLab खोलें को चुनें:
इंस्टेंस खोलने के बाद, codelab नाम की एक नई डायरेक्ट्री बनाएं. हम इस लैब में इस डायरेक्ट्री का इस्तेमाल करेंगे:
नई बनाई गई codelab डायरेक्ट्री पर डबल-क्लिक करके, उसे खोलें. इसके बाद, लॉन्चर से Python 3 नोटबुक चुनें:
नोटबुक का नाम बदलकर 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 Notebooks, BigQuery के साथ सीधे तौर पर इंटिग्रेट हो सकता है. इसके लिए, पुष्टि करने की ज़रूरत नहीं होती.
इस लैब के लिए, हम जन्मदर के डेटासेट का इस्तेमाल करेंगे. इसमें अमेरिका में पिछले 40 सालों में हुए लगभग हर बच्चे के जन्म का डेटा शामिल है. इसमें बच्चे का वज़न और उसके माता-पिता की डेमोग्राफ़िक जानकारी भी शामिल है. हम बच्चे के जन्म के समय के वज़न का अनुमान लगाने के लिए, सुविधाओं के सबसेट का इस्तेमाल करेंगे.
पहला चरण: BigQuery के डेटा को अपने नोटबुक में डाउनलोड करना
हम BigQuery के लिए Python क्लाइंट लाइब्रेरी का इस्तेमाल करेंगे, ताकि डेटा को Pandas DataFrame में डाउनलोड किया जा सके. ओरिजनल डेटासेट 21 जीबी का है और इसमें 12 करोड़ 30 लाख लाइनें हैं. हम डेटासेट की सिर्फ़ 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 है.
दूसरा चरण: ट्रेनिंग के लिए डेटासेट तैयार करना
हमने डेटासेट को Pandas DataFrame के तौर पर अपनी नोटबुक में डाउनलोड कर लिया है. अब हम इसमें कुछ प्री-प्रोसेसिंग कर सकते हैं. साथ ही, इसे ट्रेनिंग और टेस्ट सेट में बांट सकते हैं.
सबसे पहले, डेटासेट से शून्य वैल्यू वाली पंक्तियों को हटाते हैं और डेटा को शफ़ल करते हैं:
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 के साथ इंटिग्रेट किया गया है, ताकि आप सीधे तौर पर अपने नोटबुक एनवायरमेंट में वर्शन कंट्रोल कर सकें. इससे, नोटबुक के यूज़र इंटरफ़ेस (यूआई) में या JupyterLab में उपलब्ध टर्मिनल के ज़रिए कोड को कमिट किया जा सकता है. इस सेक्शन में, हम अपनी नोटबुक में git रिपॉज़िटरी को शुरू करेंगे और यूज़र इंटरफ़ेस (यूआई) के ज़रिए पहला कमिट करेंगे.
पहला चरण: git रिपॉज़िटरी शुरू करना
अपनी कोडलैब डायरेक्ट्री में, JupyterLab के सबसे ऊपर मौजूद मेन्यू बार में जाकर, Git और फिर Init चुनें:
जब आपसे पूछा जाए कि क्या आपको इस डायरेक्ट्री को Git Repo बनाना है, तो Yes चुनें. इसके बाद, बाईं ओर मौजूद साइडबार में 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() तरीके को कॉल करना है. इसके लिए, हमें ट्रेनिंग डेटा और लेबल पास करने होंगे. यहां हम validation_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 नोटबुक अब यूज़र इंटरफ़ेस (यूआई) में "बदलाव किया गया" सेक्शन में दिखनी चाहिए. फ़ाइल के नाम पर कर्सर घुमाएं और अंतर दिखाने वाले आइकॉन पर क्लिक करें:
इसके बाद, आपको अपने बदलावों का अंतर दिखना चाहिए. जैसे:
इस बार हम टर्मिनल का इस्तेमाल करके, कमांड लाइन के ज़रिए अपने बदलावों को कमिट करेंगे. JupyterLab के सबसे ऊपर मौजूद मेन्यू बार में, Git मेन्यू से Git Command in Terminal को चुनें. नीचे दिए गए कमांड चलाने के दौरान, अगर आपने बाईं ओर मौजूद साइडबार का git टैब खोला है, तो आपको git यूज़र इंटरफ़ेस (यूआई) में अपने बदलाव दिखेंगे.
अपने नए टर्मिनल इंस्टेंस में, नोटबुक फ़ाइल को कमिट करने के लिए, यह कमांड चलाएं:
git add demo.ipynb
इसके बाद, बदलावों को सेव करने के लिए यह कमांड चलाएं. आपके पास कमिट मैसेज के तौर पर कोई भी मैसेज इस्तेमाल करने का विकल्प होता है:
git commit -m "Build and train TF model"
इसके बाद, आपको इतिहास में अपनी नई कमिट दिखनी चाहिए:
6. अपनी नोटबुक से सीधे तौर पर, What-If टूल का इस्तेमाल करना
'अगर ऐसा हो, तो क्या होगा' टूल, एक इंटरैक्टिव विज़ुअल इंटरफ़ेस है. इसे आपके डेटासेट को विज़ुअलाइज़ करने और एमएल मॉडल के आउटपुट को बेहतर तरीके से समझने में मदद करने के लिए डिज़ाइन किया गया है. यह एक ओपन सोर्स टूल है. इसे Google की PAIR टीम ने बनाया है. यह किसी भी तरह के मॉडल के साथ काम करता है. हालांकि, इसमें कुछ ऐसी सुविधाएं हैं जो सिर्फ़ Cloud AI Platform के लिए बनाई गई हैं.
What-If Tool, TensorFlow के साथ Cloud AI Platform Notebooks इंस्टेंस में पहले से इंस्टॉल होता है. यहां हम इसका इस्तेमाल यह देखने के लिए करेंगे कि हमारा मॉडल कुल मिलाकर कैसा परफ़ॉर्म कर रहा है. साथ ही, हम अपने टेस्ट सेट के डेटा पॉइंट पर इसके व्यवहार की जांच करेंगे.
पहला चरण: 'अगर-तो' टूल के लिए डेटा तैयार करना
'अगर-तो' टूल का ज़्यादा से ज़्यादा फ़ायदा पाने के लिए, हम उसे अपने टेस्ट सेट से उदाहरण भेजेंगे. साथ ही, उन उदाहरणों के लिए ग्राउंड ट्रुथ लेबल (y_test) भी भेजेंगे. इससे हम यह तुलना कर सकते हैं कि हमारे मॉडल ने क्या अनुमान लगाया और ग्राउंड ट्रुथ क्या है. नीचे दिए गए कोड की लाइन को चलाकर, टेस्ट के उदाहरणों और उनके लेबल के साथ एक नया DataFrame बनाएं:
wit_data = pd.concat([x_test, y_test], axis=1)
इस लैब में, हम What-If Tool को उस मॉडल से कनेक्ट करेंगे जिसे हमने अभी-अभी अपनी नोटबुक में ट्रेन किया है. इसके लिए, हमें एक ऐसा फ़ंक्शन लिखना होगा जिसका इस्तेमाल टूल, हमारे मॉडल पर टेस्ट डेटा पॉइंट चलाने के लिए करेगा:
def custom_predict(examples_to_infer):
preds = model.predict(examples_to_infer)
return preds
दूसरा चरण: What-If Tool को इंस्टैंशिएट करना
हम What-If टूल को इंस्टैंटिएट करेंगे. इसके लिए, हम इसे अभी बनाए गए, जोड़े गए टेस्ट डेटासेट + ग्राउंड ट्रुथ लेबल से 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)
What-If टूल लोड होने पर, आपको कुछ ऐसा दिखेगा:
x-ऐक्सिस पर, आपको मॉडल के अनुमानित वेट वैल्यू, weight_pounds के हिसाब से फैले हुए टेस्ट डेटा पॉइंट दिखेंगे.
तीसरा चरण: 'अगर ऐसा हो तो क्या होगा' टूल की मदद से मॉडल के व्यवहार के बारे में जानें
'क्या होगा अगर' टूल की मदद से कई बेहतरीन काम किए जा सकते हैं. हम यहां इनमें से कुछ के बारे में जानेंगे. सबसे पहले, डेटापॉइंट एडिटर के बारे में जानते हैं. किसी भी डेटा पॉइंट को चुनकर उसकी सुविधाएं देखी जा सकती हैं. साथ ही, सुविधाओं की वैल्यू में बदलाव किया जा सकता है. किसी भी डेटा पॉइंट पर क्लिक करके शुरू करें:
बाईं ओर, आपको चुने गए डेटा पॉइंट के लिए सुविधा की वैल्यू दिखेंगी. आपके पास उस डेटा पॉइंट के ग्राउंड ट्रुथ लेबल की तुलना, मॉडल से अनुमानित वैल्यू से करने का विकल्प भी होता है. बाईं ओर मौजूद साइडबार में, सुविधा की वैल्यू को बदला जा सकता है. साथ ही, मॉडल के अनुमान को फिर से चलाया जा सकता है. इससे यह देखा जा सकता है कि इस बदलाव का आपके मॉडल पर क्या असर पड़ा. उदाहरण के लिए, इस डेटा पॉइंट के लिए, हम gestation_weeks को 30 में बदल सकते हैं. इसके लिए, इस पर दो बार क्लिक करें और अनुमान को फिर से चलाएं:
'क्या होगा अगर' टूल के प्लॉट सेक्शन में मौजूद ड्रॉपडाउन मेन्यू का इस्तेमाल करके, हर तरह के कस्टम विज़ुअलाइज़ेशन बनाए जा सकते हैं. उदाहरण के लिए, यहां एक चार्ट दिया गया है. इसमें x-ऐक्सिस पर मॉडल के अनुमानित वज़न, y-ऐक्सिस पर मां की उम्र, और पॉइंट को उनके अनुमान में हुई गड़बड़ी के हिसाब से रंग दिया गया है. ज़्यादा गहरे रंग का मतलब है कि अनुमानित और असल वज़न के बीच ज़्यादा अंतर है. यहां ऐसा लगता है कि वज़न कम होने पर, मॉडल की गड़बड़ी थोड़ी बढ़ जाती है:
इसके बाद, बाईं ओर मौजूद पार्शियल डिपेंडेंस प्लॉट बटन पर क्लिक करें. इससे पता चलता है कि हर सुविधा, मॉडल के अनुमान पर किस तरह से असर डालती है. उदाहरण के लिए, गर्भधारण की अवधि बढ़ने पर, हमारे मॉडल के हिसाब से बच्चे का अनुमानित वज़न भी बढ़ जाता है:
'अगर-तो' टूल का इस्तेमाल करके, डेटा की बारीकी से जांच करने के और आइडिया पाने के लिए, इस सेक्शन की शुरुआत में दिए गए लिंक देखें.
7. ज़रूरी नहीं: अपनी लोकल गिट रेपो को GitHub से कनेक्ट करें
आखिर में, हम यह जानेंगे कि अपने नोटबुक इंस्टेंस में मौजूद git repo को GitHub खाते में मौजूद repo से कैसे कनेक्ट करें. अगर आपको यह चरण पूरा करना है, तो आपके पास GitHub खाता होना चाहिए.
पहला चरण: GitHub पर नई रेपो बनाना
अपने GitHub खाते में, एक नई रिपॉज़िटरी बनाएं. इसे कोई नाम दें और इसका ब्यौरा लिखें. तय करें कि आपको इसे सार्वजनिक तौर पर उपलब्ध कराना है या नहीं. इसके बाद, रिपॉज़िटरी बनाएं को चुनें. आपको README फ़ाइल से इसे शुरू करने की ज़रूरत नहीं है. अगले पेज पर, आपको कमांड लाइन से किसी मौजूदा रिपॉज़िटरी को पुश करने के निर्देशों का पालन करना होगा.
टर्मिनल विंडो खोलें और अपनी नई रिपॉज़िटरी को रिमोट के तौर पर जोड़ें. नीचे दिए गए रिपो यूआरएल में, username की जगह अपना GitHub उपयोगकर्ता नाम डालें. साथ ही, your-repo की जगह उस रिपो का नाम डालें जिसे आपने अभी-अभी बनाया है:
git remote add origin git@github.com:username/your-repo.git
दूसरा चरण: अपने नोटबुक इंस्टेंस में GitHub से पुष्टि करना
इसके बाद, आपको अपने नोटबुक इंस्टेंस से GitHub में पुष्टि करनी होगी. यह प्रोसेस इस बात पर निर्भर करती है कि आपने GitHub पर दो तरीकों से पुष्टि करने की सुविधा चालू की है या नहीं.
अगर आपको नहीं पता कि कहां से शुरू करना है, तो GitHub के दस्तावेज़ में दिए गए तरीके अपनाकर, एसएसएच कुंजी बनाएं. इसके बाद, GitHub में नई कुंजी जोड़ें.
तीसरा चरण: पक्का करें कि आपने GitHub repo को सही तरीके से लिंक किया हो
यह पक्का करने के लिए कि आपने सब कुछ सही तरीके से सेट अप किया है, अपने टर्मिनल में git remote -v चलाएं. आपको अपनी नई रिपॉज़िटरी, रिमोट के तौर पर दिखेगी. जब आपको अपनी GitHub रिपॉज़िटरी का यूआरएल दिख जाए और आपने अपने नोटबुक से GitHub पर पुष्टि कर ली हो, तब आपके पास अपने नोटबुक इंस्टेंस से सीधे GitHub पर पुश करने का विकल्प होता है.
अपनी लोकल नोटबुक के Git रेपो को, नई बनाई गई GitHub रेपो के साथ सिंक करने के लिए, Git साइडबार में सबसे ऊपर मौजूद, क्लाउड पर अपलोड करने वाले बटन पर क्लिक करें:
अपनी GitHub रिपॉज़िटरी को रीफ़्रेश करें. इसके बाद, आपको अपनी नोटबुक का कोड दिखेगा. इसमें आपके पिछले कमिट भी दिखेंगे! अगर दूसरे लोगों के पास आपकी GitHub repo का ऐक्सेस है और आपको अपनी नोटबुक में हाल ही में किए गए बदलावों को सिंक करना है, तो उन बदलावों को सिंक करने के लिए, क्लाउड डाउनलोड आइकॉन पर क्लिक करें.
Notebooks git UI के इतिहास टैब में जाकर, यह देखा जा सकता है कि आपकी लोकल कमिट, GitHub के साथ सिंक हुई हैं या नहीं. इस उदाहरण में, origin/master GitHub पर मौजूद हमारी रिपो से मेल खाता है:
जब भी आपको नए कमिट करने हों, तो उन बदलावों को GitHub repo में पुश करने के लिए, क्लाउड अपलोड बटन पर फिर से क्लिक करें.
8. बधाई हो!
आपने इस लैब में काफ़ी काम किया है 👏👏👏
आपने इन कामों को करने का तरीका सीखा:
- AI Platform Notebook इंस्टेंस बनाना और उसे पसंद के मुताबिक बनाना
- उस इंस्टेंस में लोकल git repo शुरू करें, git यूज़र इंटरफ़ेस (यूआई) या कमांड लाइन के ज़रिए कमिट जोड़ें, और Notebook git यूज़र इंटरफ़ेस (यूआई) में git diff देखें
- TensorFlow 2 का सामान्य मॉडल बनाना और उसे ट्रेन करना
- अपने Notebook इंस्टेंस में, What-If टूल का इस्तेमाल करना
- अपनी नोटबुक की Git रिपॉज़िटरी को GitHub पर मौजूद किसी बाहरी रिपॉज़िटरी से कनेक्ट करना
9. साफ़-सफ़ाई सेवा
अगर आपको इस नोटबुक का इस्तेमाल जारी रखना है, तो हमारा सुझाव है कि इस्तेमाल न करने पर इसे बंद कर दें. Cloud Console में Notebooks के यूज़र इंटरफ़ेस (यूआई) में जाकर, नोटबुक चुनें. इसके बाद, बंद करें को चुनें:
अगर आपको इस लैब में बनाए गए सभी संसाधन मिटाने हैं, तो नोटबुक इंस्टेंस को बंद करने के बजाय मिटा दें.
Cloud Console में नेविगेशन मेन्यू का इस्तेमाल करके, Storage पर जाएं. इसके बाद, मॉडल ऐसेट सेव करने के लिए बनाए गए दोनों बकेट मिटाएं.