1. खास जानकारी
इस लैब में, आपको अपने डेटा को एक्सप्लोर करने और एमएल मॉडल के प्रोटोटाइप बनाने के लिए, AI Platform Notebooks के अलग-अलग टूल के बारे में बताया जाएगा.
आपको क्या सीखने को मिलेगा
आपको, इनके बारे में जानकारी मिलेगी:
- AI Platform Notebooks का इंस्टेंस बनाना और उसे पसंद के मुताबिक बनाना
- AI Platform Notebooks में सीधे तौर पर इंटिग्रेट किए गए, गिट की मदद से अपने नोटबुक कोड को ट्रैक करना
- अपनी नोटबुक में व्हाट-इफ़ टूल का इस्तेमाल करना
Google Cloud पर इस लैब को चलाने की कुल लागत एक डॉलर है. AI Platform Notebooks की कीमत के बारे में पूरी जानकारी यहां देखी जा सकती है.
2. AI Platform Notebooks इंस्टेंस बनाना
इस कोडलैब को चलाने के लिए, आपके पास बिलिंग की सुविधा वाला Google Cloud Platform प्रोजेक्ट होना चाहिए. प्रोजेक्ट बनाने के लिए, यहां दिए गए निर्देशों का पालन करें.
दूसरा चरण: Compute Engine API को चालू करना
Compute Engine पर जाएं और अगर यह पहले से चालू नहीं है, तो चालू करें को चुनें. नोटबुक इंस्टेंस बनाने के लिए, आपको इसकी ज़रूरत होगी.
तीसरा चरण: नोटबुक इंस्टेंस बनाना
अपने Cloud Console के AI Platform Notebooks सेक्शन पर जाएं और नया इंस्टेंस पर क्लिक करें. इसके बाद, जीपीयू के बिना TensorFlow 2 Enterprise का नया इंस्टेंस टाइप चुनें:
अपने इंस्टेंस को कोई नाम दें या डिफ़ॉल्ट नाम का इस्तेमाल करें. इसके बाद, हम पसंद के मुताबिक बनाने के विकल्पों के बारे में जानेंगे. पसंद के मुताबिक बनाएं बटन पर क्लिक करें:
AI Platform Notebooks में, पसंद के मुताबिक बनाने के कई विकल्प हैं. जैसे: आपका इंस्टेंस जिस इलाके में डिप्लॉय किया गया है, इमेज का टाइप, मशीन का साइज़, जीपीयू की संख्या वगैरह. हम क्षेत्र और एनवायरमेंट के लिए डिफ़ॉल्ट वैल्यू का इस्तेमाल करेंगे. मशीन कॉन्फ़िगरेशन के लिए, हम n1-standard-8 मशीन का इस्तेमाल करेंगे:
हम कोई भी जीपीयू नहीं जोड़ेंगे. साथ ही, हम बूट डिस्क, नेटवर्किंग, और अनुमति के लिए डिफ़ॉल्ट सेटिंग का इस्तेमाल करेंगे. अपना इंस्टेंस बनाने के लिए, बनाएं को चुनें. इसमें कुछ मिनट लगेंगे.
इंस्टेंस बन जाने के बाद, आपको 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 जीबी का है और इसमें 123 एम पंक्तियां हैं. चीज़ों को आसान बनाने के लिए, हम डेटासेट की सिर्फ़ 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 के साथ सीधे तौर पर इंटिग्रेट होता है. इससे, सीधे अपने नोटबुक एनवायरमेंट में वर्शन कंट्रोल किया जा सकता है. इससे, कोड को सीधे notebook के यूज़र इंटरफ़ेस (यूआई) में या JupyterLab में मौजूद टर्मिनल की मदद से कमिट किया जा सकता है. इस सेक्शन में, हम अपनी नोटबुक में एक Git रिपॉज़िटरी शुरू करेंगे और यूज़र इंटरफ़ेस (यूआई) की मदद से अपना पहला कमिट करेंगे.
पहला चरण: Git रिपॉज़िटरी को शुरू करना
अपनी codelab डायरेक्ट्री में, Git चुनें. इसके बाद, JupyterLab के सबसे ऊपर मौजूद मेन्यू बार में जाकर, Init चुनें:
जब आपसे पूछा जाए कि क्या आपको इस डायरेक्ट्री को Git रिपॉज़िटरी बनाना है, तो हां चुनें. इसके बाद, अपनी फ़ाइलों और कमिट का स्टेटस देखने के लिए, बाईं ओर मौजूद साइडबार में 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 नोटबुक अब यूज़र इंटरफ़ेस (यूआई) में "बदलाव" सेक्शन में दिखेगी. फ़ाइल के नाम पर कर्सर घुमाएं और 'अंतर' आइकॉन पर क्लिक करें:
इससे आपको अपने बदलावों का अंतर दिखेगा, जैसे कि:
इस बार, हम Terminal का इस्तेमाल करके कमांड लाइन के ज़रिए अपने बदलावों को लागू करेंगे. JupyterLab के सबसे ऊपर मौजूद मेन्यू बार में, Git मेन्यू में जाकर, Terminal में Git कमांड चुनें. अगर नीचे दिए गए निर्देशों को चलाते समय, आपके बाएं साइडबार में git टैब खुला है, तो आपको git यूज़र इंटरफ़ेस (यूआई) में अपने बदलाव दिखेंगे.
अपने नए टर्मिनल इंस्टेंस में, अपनी नोटबुक फ़ाइल को कमिट करने के लिए, यह कमांड चलाएं:
git add demo.ipynb
इसके बाद, अपने बदलावों को कमिट करने के लिए, यह कमांड चलाएं. आपके पास कमिट मैसेज के तौर पर अपनी पसंद का कोई भी मैसेज इस्तेमाल करने का विकल्प होता है:
git commit -m "Build and train TF model"
इसके बाद, आपको इतिहास में अपना नया कमिट दिखेगा:
6. सीधे अपनी नोटबुक से व्हाट-इफ़ टूल का इस्तेमाल करना
'क्या-क्या हो सकता है' टूल, एक इंटरैक्टिव विज़ुअल इंटरफ़ेस है. इसका मकसद, आपके डेटासेट को विज़ुअलाइज़ करने और एमएल मॉडल के आउटपुट को बेहतर तरीके से समझने में आपकी मदद करना है. यह एक ओपन सोर्स टूल है, जिसे Google की PAIR टीम ने बनाया है. यह किसी भी तरह के मॉडल के साथ काम करता है. हालांकि, इसमें कुछ ऐसी सुविधाएं हैं जो खास तौर पर Cloud AI Platform के लिए बनाई गई हैं.
'क्या-क्या हो सकता है' टूल, 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)
'अगर ऐसा होता है' टूल लोड होने पर, आपको कुछ ऐसा दिखेगा:
एक्स-ऐक्सिस पर, आपको अपने टेस्ट डेटा पॉइंट दिख सकते हैं. ये पॉइंट, मॉडल की अनुमानित वज़न वैल्यू, weight_pounds के हिसाब से अलग-अलग होते हैं.
तीसरा चरण: 'क्या-क्या हो सकता है' टूल की मदद से, मॉडल के व्यवहार के बारे में जानें
व्हाट-इफ़ टूल की मदद से, कई काम किए जा सकते हैं. हम यहां इनमें से कुछ के बारे में बताएंगे. सबसे पहले, डेटापॉइंट एडिटर पर नज़र डालते हैं. किसी डेटा पॉइंट की सुविधाएं देखने और उसकी वैल्यू बदलने के लिए, उसे चुना जा सकता है. किसी भी डेटा पॉइंट पर क्लिक करके शुरू करें:
बाईं ओर, आपको चुने गए डेटा पॉइंट की सुविधा की वैल्यू दिखेंगी. उस डेटा पॉइंट के ग्राउंड ट्रूथ लेबल की तुलना, मॉडल की अनुमानित वैल्यू से भी की जा सकती है. बाएं साइडबार में, सुविधा की वैल्यू बदल भी की जा सकती हैं. साथ ही, मॉडल के अनुमान को फिर से चलाकर यह देखा जा सकता है कि इस बदलाव का आपके मॉडल पर क्या असर पड़ा. उदाहरण के लिए, इस डेटा पॉइंट के लिए gestation_weeks की वैल्यू को 30 में बदला जा सकता है. इसके लिए, उस पर दो बार क्लिक करके, अनुमान फिर से चलाएं:
'अगर ऐसा होता है' टूल के प्लॉट सेक्शन में मौजूद ड्रॉपडाउन मेन्यू का इस्तेमाल करके, सभी तरह के कस्टम विज़ुअलाइज़ेशन बनाए जा सकते हैं. उदाहरण के लिए, यहां एक चार्ट दिया गया है. इसमें x-ऐक्सिस पर मॉडल के अनुमानित वजन, y-ऐक्सिस पर मां की उम्र, और अनुमान लगाने में हुई गड़बड़ी के हिसाब से रंगे गए पॉइंट दिख रहे हैं. गहरे रंग का मतलब है कि अनुमानित और असल वजन के बीच का अंतर ज़्यादा है. यहां ऐसा लगता है कि वज़न कम होने पर, मॉडल की गड़बड़ी थोड़ी बढ़ जाती है:
इसके बाद, बाईं ओर मौजूद पार्शियल डिपेंडेंस प्लॉट बटन को चुनें. इससे पता चलता है कि हर सुविधा, मॉडल के अनुमान पर कैसे असर डालती है. उदाहरण के लिए, गर्भावस्था के समय के बढ़ने के साथ-साथ, हमारे मॉडल के हिसाब से बच्चे के वजन का अनुमान भी बढ़ता है:
'क्या-क्या हो सकता है' टूल की मदद से, एक्सप्लोरेशन के ज़्यादा आइडिया पाने के लिए, इस सेक्शन की शुरुआत में दिए गए लिंक देखें.
7. ज़रूरी नहीं: अपने लोकल git repo को GitHub से कनेक्ट करना
आखिर में, हम अपने नोटबुक इंस्टेंस में मौजूद git repo को अपने GitHub खाते में मौजूद किसी repo से कनेक्ट करने का तरीका जानेंगे. अगर आपको यह चरण पूरा करना है, तो आपके पास GitHub खाता होना चाहिए.
पहला चरण: GitHub पर नया रिपॉज़िटरी बनाना
अपने GitHub खाते में, एक नया रिपॉज़िटरी बनाएं. इसे कोई नाम और ब्यौरा दें. साथ ही, यह तय करें कि आपको इसे सार्वजनिक करना है या नहीं. इसके बाद, रिपॉज़िटरी बनाएं को चुनें. आपको README से शुरू करने की ज़रूरत नहीं है. अगले पेज पर, आपको कमांड लाइन से किसी मौजूदा रिपॉज़िटरी को पुश करने के लिए निर्देशों का पालन करना होगा.
Terminal विंडो खोलें और अपनी नई रिपॉज़िटरी को रिमोट के तौर पर जोड़ें. नीचे दिए गए रिपॉज़िटरी यूआरएल में, username को अपने GitHub उपयोगकर्ता नाम से और your-repo को उस नाम से बदलें जिसे आपने अभी-अभी बनाया है:
git remote add origin git@github.com:username/your-repo.git
दूसरा चरण: अपने नोटबुक इंस्टेंस में GitHub की पुष्टि करना
इसके बाद, आपको अपने नोटबुक इंस्टेंस में जाकर, GitHub की पुष्टि करनी होगी. यह प्रोसेस इस बात पर निर्भर करती है कि आपने GitHub पर दो तरीकों से पुष्टि करने की सुविधा चालू की है या नहीं.
अगर आपको नहीं पता कि कहां से शुरू करें, तो GitHub के दस्तावेज़ में दिया गया तरीका अपनाकर एसएसएच पासकोड बनाएं. इसके बाद, GitHub में नया पासकोड जोड़ें.
तीसरा चरण: पक्का करना कि आपने GitHub का अपना रिपॉज़िटरी सही तरीके से लिंक किया हो
यह पक्का करने के लिए कि आपने सब कुछ सही तरीके से सेट अप किया है, अपने टर्मिनल में git remote -v चलाएं. आपको अपनी नई रिपॉज़िटरी, रिमोट के तौर पर दिखेगी. अपने GitHub repo का यूआरएल देखने और अपनी नोटबुक से GitHub की पुष्टि करने के बाद, सीधे अपने नोटबुक इंस्टेंस से GitHub पर पुश किया जा सकता है.
अपने स्थानीय नोटबुक git रेपो को, हाल ही में बनाए गए GitHub रेपो के साथ सिंक करने के लिए, Git साइडबार में सबसे ऊपर मौजूद क्लाउड अपलोड बटन पर क्लिक करें:
अपने GitHub डेटा स्टोर करने की जगह को रीफ़्रेश करें. इसके बाद, आपको अपने पिछले कमिट के साथ अपना नोटबुक कोड दिखेगा! अगर दूसरे लोगों के पास आपके GitHub repo का ऐक्सेस है और आपको अपनी नोटबुक में हाल ही में किए गए बदलावों को डाउनलोड करना है, तो उन बदलावों को सिंक करने के लिए, क्लाउड डाउनलोड आइकॉन पर क्लिक करें.
Notebooks के Git यूज़र इंटरफ़ेस (यूआई) के इतिहास टैब में, यह देखा जा सकता है कि आपके स्थानीय कमिट GitHub के साथ सिंक हुए हैं या नहीं. इस उदाहरण में, origin/master GitHub पर मौजूद हमारे रिपॉज़िटरी से जुड़ा है:
जब भी कोई नया बदलाव किया जाता है, तो उसे अपने GitHub repo में पुश करने के लिए, क्लाउड अपलोड बटन पर फिर से क्लिक करें.
8. बधाई हो!
आपने इस लैब में बहुत कुछ किया है 👏👏👏
ज़रूरी बातों पर फिर से एक नज़र:
- AI Platform Notebook का कस्टमाइज़ किया गया इंस्टेंस बनाना
- उस इंस्टेंस में एक लोकल Git रिपॉज़िटरी शुरू करें, Git यूज़र इंटरफ़ेस (यूआई) या कमांड-लाइन की मदद से कमिट जोड़ें, और Notebook के Git यूज़र इंटरफ़ेस (यूआई) में Git के बदलाव देखें
- TensorFlow 2 का आसान मॉडल बनाना और उसे ट्रेन करना
- अपने नोटबुक इंस्टेंस में व्हाट-इफ़ टूल का इस्तेमाल करना
- अपने Notebook के Git repo को GitHub पर किसी बाहरी डेटा स्टोर करने की जगह से कनेक्ट करना
9. साफ़-सफ़ाई सेवा
अगर आपको इस नोटबुक का इस्तेमाल जारी रखना है, तो हमारा सुझाव है कि इस्तेमाल में न होने पर इसे बंद कर दें. अपने Cloud Console में नोटबुक यूज़र इंटरफ़ेस (यूआई) से, नोटबुक चुनें. इसके बाद, रोकें को चुनें:
अगर आपको इस लैब में बनाए गए सभी संसाधन मिटाने हैं, तो नोटबुक इंस्टेंस को बंद करने के बजाय उसे मिटाएं.
अपने Cloud Console में नेविगेशन मेन्यू का इस्तेमाल करके, Storage पर जाएं और मॉडल की एसेट सेव करने के लिए बनाई गई दोनों बकेट मिटाएं.